Chrome

Unblocking Browser soporta 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 ofrece navegadores remotos de alto rendimiento que se ejecutan en servidores dedicados y utilizan proxies residenciales para la conexión. Estos entornos de navegador son rápidos, estables y altamente configurables. Pueden actuar como un reemplazo directo de su infraestructura de navegador local.

Características clave

Rendimiento rápido y estable
Selección de país de 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 proxy en Estados Unidos

Los usuarios que operan principalmente en EE. UU. pueden conectarse directamente a la infraestructura basada 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, introduzca 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 acorta principalmente el tiempo de respuesta para los usuarios basados en EE. UU., y no debe confundirse con la selección de geo-ubicación del proxy. Más sobre eso en la sección siguiente.

Selección de país

Puedes especificar un país para tu sesión del navegador añadiendo el ?p_cc parámetro para su URL de conexión. Aquí hay ejemplos:

from playwright.sync_api import sync_playwright

username = "your-username"
password = "your-password"
endpoint = "ubc.oxylabs.io"
country = "US"  # Reemplazar con el código de país deseado
browser_url = f"wss://{username}:{password}@{endpoint}?p_cc={country}"

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 country = 'US';  // Reemplazar con el código de país deseado
    const browserUrl = `wss://${username}:${password}@${endpoint}?p_cc=${country}`;

    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 country = 'US';  // Reemplazar con el código de país deseado
    const browserUrl = `wss://${username}:${password}@${endpoint}?p_cc=${country}`;

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

Si no se especifica un país, el sistema asignará uno automáticamente según la disponibilidad.

Argumentos del navegador

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

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

Actualmente, Oxylabs Unblocking Browser Chrome soporta 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

Desactiva 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 los diferentes tipos de dispositivo usando el ?p_device parámetro. Esto le permite emular huellas digitales de los tipos de dispositivo seleccionados (escritorio, móvil, tableta), lo cual es especialmente útil para extraer diseños responsivos, contenido específico para móvil o comportamientos dependientes del dispositivo como CAPTCHAs o elementos de la interfaz.

Disponible ?p_device valores de parámetros:

desktop (predeterminado) – Emula un navegador de escritorio estándar con una ventana de visualización de tamaño completo y cadena user-agent de escritorio.
búsqueda – Simula una experiencia de teléfono inteligente con una resolución de pantalla menor, capacidades táctiles y un user-agent móvil.
tablet – Emula un dispositivo tablet, ideal para extraer diseños de tamaño mediano e interfaces híbridas móvil/tableta.

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 resolverse. 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 el CAPTCHA con éxito.

oxylabs-captcha-solve-error

Se dispara cuando el solucionador automático no ha podido 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 puede tardar más, así que permita tiempo para que la resolución termine.

Consulte el siguiente ejemplo de cómo se pueden manejar estos eventos.

import asyncio
import time
from typing import Any

from playwright.async_api import async_playwright


# Complete 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 por 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 tan pronto como 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 específicas del usuario.

Unblocking Browser le permite activar la detección y resolución de CAPTCHA manualmente 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 debería mostrarse un CAPTCHA
await page.evaluate(() => {
  window.postMessage({action: 'solve_captcha', type: 'recaptcha'}, '*')
});
// Siga los eventos `oxylabs-captcha-start` y `oxylabs-captcha-end` como en un caso normal
// ...

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

// Sabemos que nuestra próxima acción puede activar 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 un caso normal
// ...

AnteriorUnblocking Browser SiguienteFirefox

Última actualización hace 11 días

¿Te fue útil?

Buenas tardes