Chrome

O Unblocking Browser suporta dois ambientes de navegador especializados, um deles é o Chrome. Saiba mais sobre como começar a usá-lo.

O ambiente Unblocking Browser Chrome fornece navegadores remotos de alto desempenho executados em servidores dedicados e usando proxies residenciais para conexão. Esses ambientes de navegador são rápidos, estáveis e altamente configuráveis. Eles podem atuar como um substituto imediato para sua infraestrutura de navegador local.

Principais recursos

Desempenho rápido e estável
Seleção de país do proxy qualquer
Compatível com Chrome DevTools Protocol (CDP)

Detalhes de conexão

Conecte-se ao UBC usando o seguinte endpoint WebSocket:

wss://ubc.oxylabs.io

Uso básico

from playwright.sync_api import sync_playwright

username = "your-username"
password = "your-password"
endpoint = "ubc.oxylabs.io"
browser_url = f"wss://{username}:{password}@{endpoint}"

with sync_playwright() as p:
    browser = p.chromium.connect_over_cdp(browser_url)
    page = browser.new_page()
    page.goto('https://example.com')
    browser.close()

import { chromium } from 'playwright';

(async () => {
    const username = 'your-username';
    const password = 'your-password';
    const endpoint = 'ubc.oxylabs.io';
    const browserUrl = `wss://${username}:${password}@${endpoint}`;

    const browser = await chromium.connectOverCDP(browserUrl);
    const page = await browser.newPage();
    await page.goto('https://example.com');
    await browser.close();
})();

import puppeteer from 'puppeteer';

(async () => {
  const username = 'your-username';
  const password = 'your-password';
  const endpoint = 'ubc.oxylabs.io';
  const browserUrl = `wss://${username}:${password}@${endpoint}`;

  const browser = await puppeteer.connect({
    browserWSEndpoint: browserUrl
  });
  const page = await browser.newPage();
  await page.goto('https://example.com');
  await browser.close();
})();

Infraestrutura de Proxy dos Estados Unidos

Usuários que operam principalmente nos EUA podem se conectar diretamente à infraestrutura baseada nos EUA através do ponto de entrada especial. Isso garante tempo de carregamento mais rápido e melhor eficiência de navegação. Para estabelecer a conexão, insira o seguinte:

wss://ubc-us.oxylabs.io

Exemplos de código:

from playwright.sync_api import sync_playwright

username = "your-username"
password = "your-password"
endpoint = "ubc-us.oxylabs.io"
browser_url = f"wss://{username}:{password}@{endpoint}"

with sync_playwright() as p:
    browser = p.chromium.connect_over_cdp(browser_url)
    page = browser.new_page()
    page.goto('https://example.com')
    browser.close()

import { chromium } from 'playwright';

(async () => {
    const username = 'your-username';
    const password = 'your-password';
    const endpoint = 'ubc-us.oxylabs.io';
    const browserUrl = `wss://${username}:${password}@${endpoint}`;

    const browser = await chromium.connectOverCDP(browserUrl);
    const page = await browser.newPage();
    await page.goto('https://example.com');
    await browser.close();
})();

import puppeteer from 'puppeteer';

(async () => {
  const username = 'your-username';
  const password = 'your-password';
  const endpoint = 'ubc-us.oxylabs.io';
  const browserUrl = `wss://${username}:${password}@${endpoint}`;

  const browser = await puppeteer.connect({
    browserWSEndpoint: browserUrl
  });
  const page = await browser.newPage();
  await page.goto('https://example.com');
  await browser.close();
})();

Observação: esta solução reduz principalmente o tempo de resposta para usuários baseados nos EUA, e não deve ser confundida com seleção de geo-localização do proxy. Mais sobre isso na seção a seguir.

Argumentos do navegador

O Unblocking Browser Chrome aceita argumentos adicionais do navegador passados com a URL de conexão no formato de ?bargs=. Esses parâmetros GET especificam argumentos de linha de comando com os quais os navegadores devem ser iniciados.

Se o argumento tiver valor, usamos bargs=argname:argvalue;
Se o argumento for apenas uma flag, usamos bargs=flagname .

Atualmente, o Oxylabs Unblocking Browser Chrome suporta os seguintes argumentos:

Argumento

Descrição

force-color-profile:<profile>

Força todos os monitores a serem tratados como se possuíssem o perfil de cor especificado.

window-position:X,Y

Especifica a posição inicial da janela.

hide-scrollbars

Evita a criação de barras de rolagem para o conteúdo web – útil para capturar screenshots consistentes.

enable-features:<feature1>,<feature2>,<feature3>

Lista separada por vírgulas de nomes de recursos a serem ativados.

disable-notifications

Desativa a API de Notificações Web e a API de Push.

Exemplo de uso:

from playwright.sync_api import sync_playwright

username = "your-username"
password = "your-password"
endpoint = "ubc.oxylabs.io"
browser_url = f"wss://{username}:{password}@{endpoint}/?bargs=force-color-profile:srgb&bargs=window-position:100,100"

with sync_playwright() as p:
    browser = p.chromium.connect_over_cdp(browser_url)
    page = browser.new_page()
    page.goto('https://example.com')
    browser.close()

Tipo de dispositivo

Você pode customizar como o navegador emula diferentes tipos de dispositivo usando o ?p_device parâmetro. Isso permite emular fingerprints dos tipos de dispositivos selecionados (desktop, mobile, tablet), o que é particularmente útil para scraping de layouts responsivos, conteúdo específico para mobile ou comportamento dependente do dispositivo, como CAPTCHAs ou elementos de interface.

Disponíveis ?p_device valores do parâmetro:

desktop (padrão) – Emula um navegador desktop padrão com viewport em tamanho completo e string de User-Agent de desktop.
mobile – Simula uma experiência de smartphone com resolução de tela menor, capacidades de toque e um User-Agent mobile.
tablet – Emula um dispositivo tablet, ideal para scraping de layouts médios e interfaces híbridas mobile/tablet.

Por exemplo:

wss://username:[email protected]?p_device=mobile

Eventos de solução de CAPTCHA

A Oxylabs registrará uma mensagem no console quando um CAPTCHA for detectado e estiver em processo de ser solucionado. 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 resolvedor automático conseguiu solucionar o CAPTCHA.

oxylabs-captcha-solve-error

Disparado quando o resolvedor automático falhou em solucionar o CAPTCHA.

Você pode assinar esses eventos para pausar sua automação e retomar somente após o CAPTCHA ter sido tratado com sucesso. Normalmente a solução de CAPTCHA leva até 30 segundos dependendo do tipo e complexidade do CAPTCHA, mas em alguns casos pode demorar mais, então permita tempo para o término da solução do CAPTCHA.

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

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

const {chromium} = require('playwright');
const sleep = require('util').promisify(setTimeout)

const
    CAPTCHA_SOLVE_START = 'oxylabs-captcha-solve-start',
    CAPTCHA_SOLVE_END = 'oxylabs-captcha-solve-end',
    CAPTCHA_SOLVE_ERROR = 'oxylabs-captcha-solve-error',

    UB_BROWSER_URL = 'wss://<username>:<password>@ubc.headlesify.io',
    CAPTCHA_CHECK_INTERVAL_SEC = 1,
    CAPTCHA_CHECK_TIMEOUT_SEC = 30,
    TARGET_URL = 'https://www.indeed.com/cmp/Bank-of-the-West/reviews?lang=any&fcountry=ALL&sort=date';

(async () => {
    console.log('Opening browser page...');
    const browser = await chromium.connectOverCDP(UB_BROWSER_URL);
    const ctx = browser.contexts()[0];
    const page = await ctx.newPage();

    // Handle console.log messages and look for Oxylabs CAPTCHA solving events
    let captchaState = null;
    page.on('console', message => {
        const msg = message.text().trim();
        if (msg.startsWith('oxylabs-captcha-')) {
            captchaState = msg;
        }
    });

    console.log('Opening target website with CAPTCHA...');
    await page.goto(TARGET_URL);

    // Wait for CAPTCHA to be solved
    for (let i = 0; i < CAPTCHA_CHECK_TIMEOUT_SEC; i++) {
        await sleep(CAPTCHA_CHECK_INTERVAL_SEC * 1000);

        // Note: for better control, you can also wait for CAPTCHA_SOLVE_START event only for certain amount of time.
        if (captchaState === CAPTCHA_SOLVE_END) {
            console.log('CAPTCHA solved successfully, continue scraping...');
            break;
        }
    }

    // Check if captcha was solved successfully
    if ([CAPTCHA_SOLVE_START, CAPTCHA_SOLVE_ERROR].includes(captchaState)) {
        console.error('Could not solve CAPTCHA. Try increasing CAPTCHA_CHECK_TIMEOUT_SEC.');
        process.exit(1);
    }

    await page.waitForSelector('h1[data-testid="PageHeader-title-reviews"]');

    console.log('Making a screenshot...');
    await page.screenshot({ path: 'page_screenshot.jpg' });

    await page.close();
    await browser.close();

    console.log('Done.');
    process.exit(0);
})();

const puppeteer = require('puppeteer');
const sleep = require('util').promisify(setTimeout);

const
    CAPTCHA_SOLVE_START = 'oxylabs-captcha-solve-start',
    CAPTCHA_SOLVE_END = 'oxylabs-captcha-solve-end',
    CAPTCHA_SOLVE_ERROR = 'oxylabs-captcha-solve-error',

    UB_BROWSER_URL = 'wss://<username>:<password>@ubc.headlesify.io',
    CAPTCHA_CHECK_INTERVAL_SEC = 1,
    CAPTCHA_CHECK_TIMEOUT_SEC = 30,
    TARGET_URL = 'https://www.indeed.com/cmp/Bank-of-the-West/reviews?lang=any&fcountry=ALL&sort=date';

(async () => {
    console.log('Opening browser page...');
    const browser = await puppeteer.connect({
        browserWSEndpoint: UB_BROWSER_URL,
        defaultViewport: null
    });

    const pages = await browser.pages();
    const page = pages.length > 0 ? pages[0] : await browser.newPage();

    // Handle console.log messages and look for Oxylabs CAPTCHA solving events
    let captchaState = null;
    page.on('console', msg => {
        const text = msg.text().trim();
        if (text.startsWith('oxylabs-captcha-')) {
            captchaState = text;
        }
    });

    console.log('Opening target website with CAPTCHA...');
    await page.goto(TARGET_URL, { waitUntil: 'domcontentloaded' });

    for (let i = 0; i < CAPTCHA_CHECK_TIMEOUT_SEC; i++) {
        await sleep(CAPTCHA_CHECK_INTERVAL_SEC * 1000);

        if (captchaState === CAPTCHA_SOLVE_END) {
            console.log('CAPTCHA solved successfully, continue scraping...');
            break;
        }
    }

    if ([CAPTCHA_SOLVE_START, CAPTCHA_SOLVE_ERROR].includes(captchaState)) {
        console.error('Could not solve CAPTCHA. Try increasing CAPTCHA_CHECK_TIMEOUT_SEC.');
        process.exit(1);
    }

    await page.waitForSelector('h1[data-testid="PageHeader-title-reviews"]');

    console.log('Making a screenshot...');
    await page.screenshot({ path: 'page_screenshot.jpg' });

    await page.close();
    await browser.disconnect();  // use disconnect for remote sessions

    console.log('Done.');
    process.exit(0);
})();

Solução dinâmica de CAPTCHA

Por padrão, o Unblocking Browser detecta automaticamente e resolve CAPTCHAs imediatamente quando uma página carrega. No entanto, alguns sites exibem CAPTCHAs em estágios posteriores, como janelas popup ao enviar formulários ou após interações específicas do usuário.

O Unblocking Browser permite que você acione a detecção e solução de CAPTCHA manualmente em qualquer ponto durante sua sessão. Para acionar manualmente a solução de CAPTCHA, execute o seguinte código para enviar uma mensagem ao objeto window:

window.postMessage({action: 'solve_captcha', type: '<captcha type>'}, '*')

Tipos de CAPTCHA suportados incluem:

hcaptcha
recaptcha
turnstile (CAPTCHA do Cloudflare)

Exemplo de uso (Playwright / Puppeteer JavaScript):

// ...
await page.click('#form-submit');
// Now we know that CAPTCHA should be shown
await page.evaluate(() => {
  window.postMessage({action: 'solve_captcha', type: 'recaptcha'}, '*')
});
// Follow `oxylabs-captcha-start` and `oxylabs-captcha-end` events like a regular case
// ...

Turnstile CAPTCHA requer uma abordagem diferente, já que deve ser interceptado antes de aparecer na tela. Para isso, inicie primeiro a detecção do CAPTCHA e então execute a ação que o aciona:

// We know that our next action may trigger Turnstile CAPTCHA
await page.evaluate(() => {
  window.postMessage({action: 'solve_captcha', type: 'turnstile'}, '*')
});
await page.click('#form-submit');
// Follow `oxylabs-captcha-start` and `oxylabs-captcha-end` events like a regular case
// ...

AnteriorUnblocking Browser PróximoFirefox

Atualizado há 12 dias

Isto foi útil?

Boa tarde

hashtagPrincipais recursos

hashtagDetalhes de conexão

hashtagUso básico

hashtagInfraestrutura de Proxy dos Estados Unidos

hashtagArgumentos do navegador

hashtagTipo de dispositivo

hashtagEventos de solução de CAPTCHA

hashtagSolução dinâmica de CAPTCHA