Chrome

Unblocking Browser admite dos entornos de navegador especializados, uno de los cuales es Chrome. Aprende más sobre cómo empezar a usarlo.

El entorno Unblocking Browser Chrome proporciona navegadores remotos de alto rendimiento que se ejecutan en servidores dedicados y usan proxies residenciales para la conexión. Estos entornos de navegador son rápidos, estables y altamente configurables. Pueden actuar como un reemplazo directo para su infraestructura de navegador local.

Características clave

Rendimiento rápido y estable
Selección de país del proxy cualquiera
Compatible con Chrome DevTools Protocol (CDP)

Detalles de conexión

Conéctese a UBC usando el siguiente 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();
})();

Infraestructura de proxies en Estados Unidos

Los usuarios que operan principalmente en EE. UU. pueden conectarse directamente a la infraestructura ubicada en EE. UU. a través del punto de entrada especial. Esto garantiza tiempos de carga más rápidos y una mejor eficiencia de navegación. Para establecer la conexión, ingrese lo siguiente:

wss://ubc-us.oxylabs.io

Ejemplos 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();
})();

Nota: esta solución principalmente acorta el tiempo de respuesta para los usuarios basados en EE. UU., y no debe confundirse con la selección de geolocalización del proxy. Más sobre eso en la siguiente sección.

Argumentos del navegador

Unblocking Browser Chrome acepta argumentos adicionales del navegador pasados con la URL de conexión en el formato ?bargs=. Estos parámetros GET especifican argumentos de línea de comandos con los que debe iniciarse el navegador.

Si el argumento debe tener un valor, usamos bargs=argname:argvalue;
Si el argumento es solo una bandera, usamos bargs=flagname .

Actualmente, Oxylabs Unblocking Browser Chrome admite los siguientes argumentos:

Argumento

Descripción

force-color-profile:<profile>

Forzar que todos los monitores se traten como si tuvieran el perfil de color especificado.

window-position:X,Y

Especifica la posición inicial de la ventana.

hide-scrollbars

Evita crear barras de desplazamiento para el contenido web; útil para tomar capturas de pantalla consistentes.

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

Lista separada por comas de nombres de funciones para habilitar.

disable-notifications

Deshabilita las APIs Web Notification y Push.

Ejemplo 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

Puede personalizar cómo el navegador emula diferentes tipos de dispositivos usando el ?p_device parámetro. Esto le permite emular huellas del tipo de dispositivo seleccionado (escritorio, móvil, tablet), lo cual es particularmente útil para scrapear diseños responsivos, contenido específico para móvil o comportamiento dependiente del dispositivo como CAPTCHAs o elementos de la IU.

Disponible ?p_device valores del parámetro:

desktop (predeterminado) – Emula un navegador de escritorio estándar con una ventana de visualización de tamaño completo y una cadena de User-Agent de escritorio.
mobile – Simula una experiencia de smartphone con una resolución de pantalla menor, capacidades táctiles y un User-Agent móvil.
tablet – Emula un dispositivo tablet, ideal para scrapear diseños de tamaño mediano e interfaces híbridas móvil/tablet.

Por ejemplo:

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

Eventos de resolución de CAPTCHA

Oxylabs registrará un mensaje en la consola cuando se detecte 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 comenzado 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.

Puede suscribirse a estos eventos para pausar su 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 tomar más tiempo, así que permita tiempo para que la resolución termine.

Consulte el ejemplo a continuación de cómo se pueden manejar estos eventos.

import asyncio
import time
from typing import Any

from playwright.async_api import async_playwright


# Rellene el nombre de usuario y la contraseña
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

    # reemplazar con la URL de su elección
    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);
})();

Resolución dinámica de CAPTCHA

Por defecto, Unblocking Browser detecta y resuelve CAPTCHAs automáticamente inmediatamente cuando se carga una página. Sin embargo, algunos sitios web muestran CAPTCHAs en etapas posteriores, como ventanas emergentes al enviar formularios o después de interacciones de usuario específicas.

Unblocking Browser le permite activar manualmente la detección y resolución de CAPTCHA en cualquier momento durante su sesión. Para activar manualmente la resolución de CAPTCHA, ejecute el siguiente código para enviar un mensaje al objeto window:

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

Los tipos de CAPTCHA compatibles incluyen:

hcaptcha
recaptcha
turnstile (CAPTCHA de Cloudflare)

Ejemplo de uso (Playwright / Puppeteer JavaScript):

// ...
await page.click('#form-submit');
// Ahora sabemos que se debe mostrar un CAPTCHA
await page.evaluate(() => {
  window.postMessage({action: 'solve_captcha', type: 'recaptcha'}, '*')
});
// Siga los eventos `oxylabs-captcha-start` y `oxylabs-captcha-end` como en el caso habitual
// ...

Turnstile CAPTCHA requiere un enfoque diferente ya que debe interceptarse antes de que aparezca en pantalla. Para hacerlo, inicie primero la detección de CAPTCHA y luego realice la acción que desencadena el CAPTCHA:

// Sabemos que nuestra próxima acción puede desencadenar Turnstile CAPTCHA
await page.evaluate(() => {
  window.postMessage({action: 'solve_captcha', type: 'turnstile'}, '*')
});
await page.click('#form-submit');
// Siga los eventos `oxylabs-captcha-start` y `oxylabs-captcha-end` como en el caso habitual
// ...

AnteriorUnblocking Browser SiguienteFirefox

Última actualización hace 8 días

¿Te fue útil?

Buenos días

hashtagCaracterísticas clave

hashtagDetalles de conexión

hashtagUso básico

hashtagInfraestructura de proxies en Estados Unidos

hashtagArgumentos del navegador

hashtagTipo de dispositivo

hashtagEventos de resolución de CAPTCHA

hashtagResolución dinámica de CAPTCHA