# Cómo usar un proxy con Browser Use

Source: https://ipvolt.com/es/guides/browser-use-proxy-setup
Markdown: https://ipvolt.com/es/guides/browser-use-proxy-setup.md
Language: es

[Inicio de ipvolt](https://ipvolt.com/es.md) / [Guías](https://ipvolt.com/es/guides.md) / Cómo usar un proxy con Browser Use

Integración
Publicado: 2026-11-18
11 min de lectura
Por ipvolt

Añade un proxy HTTP o SOCKS5 a un agente de Browser Use 1.0: configuración probada con Playwright, por qué falla SOCKS5 con contraseña, rotación y sesiones.

Browser Use 1.0 no tiene ajuste de proxy para el navegador que inicia en tu equipo. Para que un agente salga por tu propio proxy, inicia tú Chromium con el proxy y entrégale ese navegador al agente por CDP, el [Chrome DevTools Protocol](https://chromedevtools.github.io/devtools-protocol/) con el que [browser-harness](https://github.com/browser-use/browser-harness), el motor de Browser Use, controla Chrome. Si lo lanzas con Playwright, bastan unas líneas y funciona con un proxy HTTP que pide usuario y contraseña.

Probado el 18 de noviembre de 2026 con browser-use 1.0.6, browser-harness 0.1.13, Playwright 1.65.2 (su Chromium 159.0.8154.6), Google Chrome 157.0.8103.79 y Python 3.12.16 en macOS 26.5.1. Debajo de cada bloque de código decimos qué se ejecutó y qué no.

## Respuesta corta

Toda la configuración del proxy en Browser Use son dos llamadas:

```python
context = await p.chromium.launch_persistent_context(
    profile,
    proxy={'server': 'http://HOST:PORT', 'username': 'USERNAME', 'password': 'PASSWORD'},
    args=['--remote-debugging-port=9242'],
)
agent = Agent(task, browser=Browser(cdp_url='http://127.0.0.1:9242'))
```

Playwright inicia Chromium a través de tu proxy y responde a su petición de acceso, y `Browser(cdp_url=...)` le pasa ese navegador al agente, así que cada página que abre el agente pasa por el proxy. Es un extracto del script completo de abajo y no se ejecuta por sí solo.

¿Por qué no un ajuste de Browser Use? En la 1.0 la antigua opción `proxy` solo existe para los navegadores en la nube; para un navegador local, la [página Browsers](https://docs.browser-use.com/open-source/browsers) dice «Local: not yet», y `ProxySettings` ahora lanza el error [«Browser('chromium') has no proxy yet»](https://github.com/browser-use/browser-use/blob/1.0.6/browser_use/legacy.py#L211). Conectarse con `cdp_url` es la forma documentada de controlar [cualquier navegador con un endpoint CDP](https://docs.browser-use.com/open-source/browsers#any-cdp-endpoint), como en el [ejemplo con Playwright](https://docs.browser-use.com/open-source/examples#combine-with-playwright) de la propia documentación. Esta guía trata solo la 1.0.

## Qué necesitas

- Python 3.11 o posterior y uv, como en el [quickstart de Browser Use](https://docs.browser-use.com/open-source/quickstart).
- Un proxy: host, puerto, usuario y contraseña. Los comandos de abajo usan marcadores.
- Una clave para el modelo. Por defecto, `Agent` usa el modelo de Browser Use y lee `BROWSER_USE_API_KEY`; [otros modelos](https://docs.browser-use.com/open-source/models) se pasan en `llm=`.

```sh
uv init --python 3.12 browser-use-proxy && cd browser-use-proxy
uv add 'browser-use==1.0.6' playwright
uv run playwright install chromium
```

```sh
export PROXY_HOST=proxy.example.com
export PROXY_PORT=8080
export PROXY_USER=USERNAME
export PROXY_PASS=PASSWORD
export BROWSER_USE_API_KEY=YOUR_KEY
```

Ejecutamos los comandos de instalación tal cual; el segundo bloque contiene marcadores para tus propios valores. En un [proxy móvil](/mobile-proxies) de ipvolt son el host, el puerto HTTP, el usuario y la contraseña de la ficha del dispositivo. En los [proxies residenciales](/residential-proxies), el host es `res.ipvolt.com`, el puerto HTTP es `7000`, el usuario es el que el panel arma para tu red y tu país, y la contraseña es tu clave ([inicio rápido residencial](/docs/residential-quickstart)).

## Un ejemplo completo que funciona

Guarda esto como `agent_proxy.py`:

```python
import asyncio
import json
import os
import tempfile
from pathlib import Path

from playwright.async_api import async_playwright

from browser_use import Agent, Browser

PROXY = {
    'server': f"http://{os.environ['PROXY_HOST']}:{os.environ['PROXY_PORT']}",
    'username': os.environ['PROXY_USER'],
    'password': os.environ['PROXY_PASS'],
}
CDP_PORT = 9242


def fresh_profile() -> str:
    """A new Chrome profile in which WebRTC cannot go around the proxy."""
    profile = tempfile.mkdtemp(prefix='agent-')
    prefs = Path(profile, 'Default', 'Preferences')
    prefs.parent.mkdir()
    prefs.write_text(json.dumps({'webrtc': {'ip_handling_policy': 'disable_non_proxied_udp'}}))
    return profile


async def main():
    async with async_playwright() as p:
        context = await p.chromium.launch_persistent_context(
            fresh_profile(),
            headless=True,
            proxy=PROXY,
            args=[f'--remote-debugging-port={CDP_PORT}'],
        )
        try:
            page = context.pages[0]
            await page.goto('https://api.ipify.org')
            print('Exit IP, checked by Playwright:', await page.inner_text('body'))

            agent = Agent(
                'Open https://api.ipify.org in the browser and return only the IP address it shows.',
                browser=Browser(cdp_url=f'http://127.0.0.1:{CDP_PORT}'),
            )
            result = await agent.run()
            print('Exit IP, reported by the agent:', result.final_result())
        finally:
            await context.close()


asyncio.run(main())
```

Ejecútalo con `uv run agent_proxy.py`. La primera línea sale solo de Playwright, así que confirma el proxy antes de que el modelo haga nada; la segunda es la respuesta del agente.

```text
Exit IP, checked by Playwright: 203.0.113.24
Exit IP, reported by the agent: 203.0.113.24
```

Qué se ejecutó: este mismo archivo, con un proxy de prueba que exige usuario y contraseña y sale a internet desde nuestro propio servidor. Sin clave de API para el modelo, un sustituto programado (un `FunctionModel` de Pydantic AI) ocupó el lugar del modelo al ejecutar y devolvió el texto de la página; el navegador, el proxy, la conexión CDP y el bucle del agente fueron reales. La salida muestra una dirección de documentación ([RFC 5737](https://www.rfc-editor.org/rfc/rfc5737.html)) en lugar de la de nuestro servidor. Un modelo real redacta su propia respuesta.

Tres detalles del script importan:

- `fresh_profile()` escribe una preferencia de Chrome que impide que WebRTC revele tu dirección real; consulta las fugas de WebRTC en «Solución de problemas», más abajo.
- El puerto de depuración está abierto a cualquier programa del equipo, como la documentación [advierte para los navegadores locales](https://docs.browser-use.com/open-source/browsers#local-chromium); en un equipo compartido, usa un contenedor.
- Un agente conectado con `cdp_url` deja el navegador en marcha al terminar, así que lo detiene `context.close()`.

[Alquilar un proxy móvil por 1 día: Alemania, O2, US$9](/dashboard/mobile?country=DE&plan=day&carrier=O2)

No necesitas cuenta. Paga con criptomonedas y guarda el ID de la factura; la página del pedido muestra entonces el host, los puertos, el usuario y la contraseña para el script.

## Autenticación: HTTP y SOCKS5

Probamos cada forma de pasar las credenciales en Google Chrome 157 y en el Chromium 159 de Playwright, con el mismo resultado:

| Configuración | Resultado |
| --- | --- |
| `proxy` de Playwright con `username` y `password`, proxy HTTP | Funciona, también en las pestañas que abre el agente |
| `proxy` de Playwright con `username` y `password`, proxy SOCKS5 | No arranca: `Browser does not support socks5 proxy authentication` |
| Proxy SOCKS5 sin contraseña, `socks5://HOST:PORT` | Funciona |
| Credenciales en la opción de Chrome, `--proxy-server=http://USER:PASS@HOST:PORT` | `net::ERR_NO_SUPPORTED_PROXIES` |
| `--proxy-server` sin credenciales, el proxy pide contraseña | HTTP: `net::ERR_INVALID_AUTH_CREDENTIALS`; SOCKS5: `net::ERR_SOCKS_CONNECTION_FAILED` |

La [documentación de Chromium sobre proxies](https://chromium.googlesource.com/chromium/src/+/HEAD/net/docs/proxy.md) lo explica: Chrome «will not use any credentials embedded in the proxy settings», y «No authentication methods are supported for SOCKSv5 in Chrome», aunque el protocolo tiene uno ([RFC 1929](https://www.rfc-editor.org/rfc/rfc1929.html)). La respuesta 407 de un proxy HTTP ([RFC 9110](https://www.rfc-editor.org/rfc/rfc9110.html#name-407-proxy-authentication-re)) necesita que alguien conteste, y lo hace el lanzador de Playwright; su [opción proxy](https://playwright.dev/python/docs/api/class-browsertype#browser-type-launch-persistent-context) documenta usuario y contraseña solo para proxies HTTP. Las demás opciones de proxy de Playwright están en [configurar un proxy en Playwright](/es/guides/playwright-proxy-setup).

Así que usa el endpoint HTTP del proxy cuando pida contraseña. Si necesitas SOCKS5 con contraseña, ejecuta un reenviador local que añada las credenciales y apunta el navegador a él:

```sh
uv run --with pproxy pproxy -l http://127.0.0.1:8899 -r "socks5://$PROXY_HOST:$PROXY_PORT#$PROXY_USER:$PROXY_PASS"
```

Después ejecuta el ejemplo con `PROXY_HOST=127.0.0.1` y `PROXY_PORT=8899`; el reenviador nunca pide contraseña. `#user:password` es la [sintaxis de pproxy](https://github.com/qwj/python-proxy) para el acceso a un proxy remoto, y escuchar en `127.0.0.1` impide que otros usen tu proxy a través de él. Qué se ejecutó: este mismo comando con nuestro proxy SOCKS5 de prueba con contraseña, y después `agent_proxy.py`, que mostró la dirección de salida de prueba.

## En tu equipo o en Browser Use Cloud

- **En tu equipo** (esta guía): cualquier proxy que acepte Chromium, HTTP o SOCKS5, con las reglas de arriba. Del proxy se encarga el navegador; Browser Use no interviene.
- **Browser Use Cloud:** `Browser()` sin argumentos es un navegador en la nube con un proxy residencial activado por defecto; `cloud_proxy_country_code='de'` elige otro país y `None` lo desactiva ([Browsers: Cloud browser](https://docs.browser-use.com/open-source/browsers#cloud-browser)). La [página Proxies](https://docs.browser-use.com/cloud/browser/proxies) presenta el proxy propio como una función enterprise que activa el equipo de ventas (los proyectos creados antes del 13 de noviembre de 2026 conservan el acceso), con host, puerto, usuario y contraseña opcionales, y `http` o `https`. Permite cambiar el proxy de un navegador independiente sin reiniciarlo, y `{"rotate": true}` pide una nueva IP residencial en el mismo país.

El `Browser()` de la biblioteca solo acepta el código de país. El proxy propio se pone en navegadores creados con la API, que se controlan con [Playwright u otro cliente CDP](https://docs.browser-use.com/cloud/browser/playwright-puppeteer-selenium); conectar uno con `Browser(cdp_url=...)` seguiría el esquema de esta guía. No teníamos clave para la nube, así que en la nube no se ejecutó nada.

## Rotación y sesiones

Dos reglas bastan para la mayoría de los agentes:

- **Una IP nueva entre tareas:** inicia un navegador nuevo para cada trabajo y cambia la salida antes de empezar.
- **La misma IP mientras hay sesión iniciada:** mantén un navegador y una sesión de proxy para todas las tareas que necesitan el acceso. Varios agentes pueden usarlo uno tras otro.

Las cookies viven en el perfil del navegador y la salida la decide el proxy, así que ninguna de las dos debe cambiar mientras el agente tiene la sesión iniciada ([proxies rotativos o fijos](/es/guides/rotating-vs-sticky-proxies)).

```python
import asyncio
import json
import os
import secrets
import tempfile
import urllib.request

from playwright.async_api import async_playwright

from browser_use import Agent, Browser

SERVER = f"http://{os.environ['PROXY_HOST']}:{os.environ['PROXY_PORT']}"
CDP_PORT = 9242
CHECK = 'Open https://api.ipify.org in the browser and return only the IP address it shows.'


def rotate_mobile_ip():
    """Dedicated mobile proxy: ask the device for a new IP with its rotation link."""
    with urllib.request.urlopen(os.environ['ROTATION_LINK'], timeout=90) as response:
        print('rotation:', json.load(response))


def sticky_username(job: str) -> str:
    """Residential or mobile per GB: a session ID keeps one exit for the whole job."""
    return f"{os.environ['PROXY_USER']}-sid-{job}-rot-sticky-ttl-3600"


async def run_job(p, username, tasks):
    """One browser per job: one exit and one cookie jar for every task in it."""
    context = await p.chromium.launch_persistent_context(
        tempfile.mkdtemp(),
        headless=True,
        args=[f'--remote-debugging-port={CDP_PORT}'],
        proxy={'server': SERVER, 'username': username, 'password': os.environ['PROXY_PASS']},
    )
    try:
        for task in tasks:
            result = await Agent(task, browser=Browser(cdp_url=f'http://127.0.0.1:{CDP_PORT}')).run()
            print(username, '->', result.final_result())
    finally:
        await context.close()


async def main():
    mobile = os.environ.get('PROXY_KIND', 'mobile') == 'mobile'
    async with async_playwright() as p:
        for job in range(2):
            if mobile:
                if job:
                    rotate_mobile_ip()
                username = os.environ['PROXY_USER']
            else:
                username = sticky_username(f'job{job}_{secrets.token_hex(4)}')
            await run_job(p, username, [CHECK, CHECK])


asyncio.run(main())
```

Cómo se aplica al proxy que uses:

- **Proxy móvil, un dispositivo dedicado:** una sola IP a la vez, compartida por todas las conexiones de un trabajo con sesión iniciada. Entre trabajos, llama al [enlace de rotación](/docs/rotation) del dispositivo (`ROTATION_LINK`, en More controls del panel cuando el dispositivo lo tiene) o pulsa Rotar IP. Mantén desactivada la rotación automática mientras haya sesión iniciada y empieza el siguiente trabajo cuando la rotación haya terminado.
- **Residencial o IP móviles por GB:** la sesión forma parte del usuario. Sin ID de sesión, cada conexión vuelve a elegir salida, y un navegador abre muchas conexiones por página. Añade uno: `-sid-NAME-rot-sticky-ttl-3600` pide a la pasarela mantener una salida durante una hora, y un ID nuevo inicia una sesión nueva. Los ID admiten letras minúsculas, dígitos y guiones bajos, hasta 64 caracteres ([segmentación y sesiones](/docs/residential-sessions)).

Qué se ejecutó: `rotate.py` tal cual, con el modelo programado, en los dos modos. El modo móvil se ejecutó con nuestro propio proxy HTTP de prueba y un sustituto local del enlace de rotación; el modo de sesión, con un proxy de prueba que ignora el usuario. En cada trabajo, dos agentes trabajaron uno tras otro en un mismo navegador. Las rotaciones y sesiones reales ocurren en el proxy y no se probaron aquí.

## Móvil o residencial para un agente

Elige según lo que hace el agente, no solo por el tipo de IP. [Proxies móviles o residenciales](/es/guides/mobile-vs-residential-proxies) tiene una tabla para evaluar ambos.

- **Un proxy móvil dedicado** encaja con un agente que mantiene la sesión en una sola cuenta o que necesita un país y un operador concretos. Nadie más usa el dispositivo durante el alquiler, y su dirección es una dirección de operador, que los operadores suelen compartir entre muchos abonados ([RFC 6888](https://www.rfc-editor.org/rfc/rfc6888.html)).
- **Los proxies residenciales** encajan con muchos trabajos cortos e independientes en varios países, con pago por GB y una sesión fija para cada trabajo.
- **Los [proxies móviles compartidos](/shared-mobile-proxies)** son direcciones de operador de un pool compartido de módems, con pago por GB como los residenciales.

Un proxy cambia la dirección y nada más. No sirve cuando el bloqueo viene del navegador (una huella de modo headless o de automatización), del comportamiento (velocidad, repetición) o de un muro de acceso o un CAPTCHA ligados a la cuenta. Compruébalo: ejecuta la misma tarea en un navegador normal desde tu propia conexión. Si también se bloquea ahí, la causa no es la IP. [Bloqueos de Cloudflare a agentes de IA: qué arreglar primero](/es/blog/cloudflare-ai-agent-proxy-setup) repasa esos casos.

## Ancho de banda

Un navegador carga todas las imágenes, fuentes, scripts y vídeos de una página, y Chrome añade peticiones propias. En nuestra prueba, Google Chrome inactivo durante 30 segundos en una página en blanco abrió 21 conexiones por el proxy en una ejecución y 22 en otra, sobre todo a servicios de Google, y 13 con `--disable-background-networking`. El Chromium de Playwright abrió 4 o 5.

- **Planes por GB:** todo eso cuenta. Los residenciales cuestan desde US$0.60 por GB, en paquetes desde US$5. Las IP móviles por GB cuestan desde US$3 por GB en los países de su pool compartido. Calcula antes con [cuántos GB de proxy necesito](/es/blog/how-many-gb-of-proxies-do-i-need) y recorta imágenes y fuentes con [bloquear imágenes y fuentes en Playwright](/es/guides/playwright-block-images-save-bandwidth). No medimos el bloqueo con un agente conectado.
- **Un alquiler móvil por día:** se paga por tiempo, sin límite de tráfico, desde US$9 al día. Las páginas pesadas no cambian el precio; [alquilar un proxy móvil por 1 día](/es/blog/mobile-proxy-1-day) lo compara con 30 días.

## Solución de problemas

- **Se requiere autenticación en el proxy.** Con el lanzador de Playwright, una contraseña incorrecta apareció como `Page.goto: Timeout 30000ms exceeded` en Chromium 159 y como `net::ERR_HTTP_RESPONSE_CODE_FAILURE` en Chrome 157, no como un 407. Comprueba las credenciales con una petición de curl y después lee [cómo corregir el error de proxy 407](/es/guides/fix-proxy-error-407).
- **`net::ERR_NO_SUPPORTED_PROXIES`.** Las credenciales están dentro de `--proxy-server`. Pásalas a la opción `proxy` de Playwright o usa el reenviador de arriba.
- **Fallo del túnel.** `net::ERR_TUNNEL_CONNECTION_FAILED` significa que el proxy rechazó el CONNECT; [cómo corregir ERR_TUNNEL_CONNECTION_FAILED](/es/guides/fix-err-tunnel-connection-failed) lee su respuesta. Un 502 o 503 justo después de una rotación se trata en [fallo de túnel: 502/503](/es/guides/fix-proxy-tunnel-502-503).
- **Tiempos de espera.** Separa un proxy lento de una página lenta con [diagnosticar tiempos de espera del proxy](/es/guides/proxy-timeout-troubleshooting).
- **El proxy parece ignorado.** La parte de red propia del agente en Python (`http_get`, `requests`) se ejecuta en tu equipo: en nuestra prueba, `http_get` devolvió la dirección del equipo mientras la página mostraba la del proxy, como la documentación dice de los navegadores en la nube. Escribe «en el navegador» en la tarea y comprueba que está `browser=Browser(cdp_url=...)`: sin él, `Agent` inicia un navegador en la nube. Para herramientas que leen variables de proxy, consulta [variables de entorno del proxy](/es/guides/proxy-environment-variables).
- **Fugas de DNS.** Los registros de nuestro proxy mostraron que Chrome envía el nombre del host al proxy por HTTP y por SOCKS5, así que los destinos no se resuelven en local; la documentación de Chromium lo confirma para SOCKS5. [socks5 y socks5h, probados](/es/blog/socks5-vs-socks5h) muestra clientes que se comportan de otra forma.
- **Fugas de WebRTC.** Por defecto, una página podía leer por WebRTC las direcciones públicas reales IPv4 e IPv6 del equipo en los dos navegadores, y la opción que se suele recomendar, `--force-webrtc-ip-handling-policy=disable_non_proxied_udp`, no cambió nada. La preferencia de perfil `webrtc.ip_handling_policy` con el valor `disable_non_proxied_udp`, que escribe `fresh_profile()`, eliminó todos los candidatos. Es el ajuste detrás de la [política WebRtcIPHandling](https://chromium.googlesource.com/chromium/src/+/HEAD/components/policy/resources/templates/policy_definitions/WebRtc/WebRtcIPHandling.yaml) de Chrome, el modo «force proxy» del [RFC 8828](https://www.rfc-editor.org/rfc/rfc8828.html#section-5.2). Compruébalo con [comprobar fugas de IP, DNS y WebRTC](/es/blog/proxy-leak-check-todetect) o con nuestro [comprobador de proxies](/tools/proxy-checker).

## Preguntas

### ¿Cómo configuro un proxy en Browser Use?

Inicia Chromium con la opción `proxy` de Playwright y un puerto de depuración, y pásale al agente `Browser(cdp_url='http://127.0.0.1:9242')`. La versión 1.0 no tiene opción de proxy para navegadores locales.

### ¿Browser Use admite proxies SOCKS5?

Sí, sin contraseña: `socks5://HOST:PORT`. Chromium no puede enviar credenciales SOCKS5, así que usa el endpoint HTTP o un reenviador local.

### ¿Puedo usar un proxy residencial con Browser Use?

Sí. Pon la pasarela en la opción `proxy` y un ID de sesión fija en el usuario, para que la salida se mantenga mientras el agente tiene la sesión iniciada.

### ¿Puedo usar un proxy móvil con Browser Use?

Sí. Usa el puerto HTTP, el usuario y la contraseña del dispositivo, y rota su IP de operador entre tareas.

### ¿Cuál es el mejor proxy para agentes de IA?

Depende de la tarea: un proxy móvil dedicado para sesiones largas con inicio de sesión o un operador concreto, residencial para muchos trabajos cortos en varios países. Ningún proxy arregla un bloqueo por huella del navegador.

### ¿Browser Use Cloud incluye proxy?

Sí, un proxy residencial, en Estados Unidos salvo que elijas otro país. Un proxy propio allí es una función enterprise.

### ¿Por qué el agente sigue mostrando mi IP real?

Normalmente la petición no salió del navegador: los ayudantes de Python del agente se ejecutan en tu equipo. Pide la página en el navegador y bloquea WebRTC con `fresh_profile()`.

**Pon tu agente en una IP de operador.** Un proxy móvil dedicado de ipvolt cuesta desde US$9 al día, sin límite de tráfico, por HTTP y SOCKS5. El [Proxy Toolkit MCP](/mcp) gratuito le da a un agente de programación configuraciones de proxy, diagnóstico de errores y estas guías. Por GB, los [proxies residenciales](/residential-proxies) cuestan desde US$0.60 por GB, en paquetes desde US$5. Compara todas las opciones en [Precios](/pricing) y prueba cualquier proxy con el [comprobador de proxies](/tools/proxy-checker). Los agentes también pueden [alquilar a través de la API](/docs/ai-agents) y recargar con sus propios USDC.

[Alquilar un proxy móvil por 1 día: Alemania, O2, US$9](/dashboard/mobile?country=DE&plan=day&carrier=O2)

No necesitas cuenta.

## Fuentes y lecturas adicionales

- [Browser Use: Browsers (cloud, local Chromium, any CDP endpoint)](https://docs.browser-use.com/open-source/browsers)
- [Browser Use: Examples, Combine with Playwright](https://docs.browser-use.com/open-source/examples#combine-with-playwright)
- [Browser Use: Quickstart](https://docs.browser-use.com/open-source/quickstart)
- [Browser Use: Models](https://docs.browser-use.com/open-source/models)
- [Browser Use: Migrating from 0.x (proxy: local dropped for now)](https://docs.browser-use.com/open-source/migrating)
- [Browser Use Cloud: Proxies](https://docs.browser-use.com/cloud/browser/proxies)
- [Browser Use Cloud: Playwright, Puppeteer, Selenium](https://docs.browser-use.com/cloud/browser/playwright-puppeteer-selenium)
- [browser-use 1.0.6 source: ProxySettings removal note (legacy.py)](https://github.com/browser-use/browser-use/blob/1.0.6/browser_use/legacy.py#L211)
- [browser-use 1.0.6 source: local Chrome launch flags (browser/local.py)](https://github.com/browser-use/browser-use/blob/1.0.6/browser_use/browser/local.py#L332)
- [browser-harness: the engine inside Browser Use](https://github.com/browser-use/browser-harness)
- [Chrome DevTools Protocol](https://chromedevtools.github.io/devtools-protocol/)
- [Playwright for Python: BrowserType.launch_persistent_context (proxy, args)](https://playwright.dev/python/docs/api/class-browsertype#browser-type-launch-persistent-context)
- [Chromium: proxy support in Chrome](https://chromium.googlesource.com/chromium/src/+/HEAD/net/docs/proxy.md)
- [Chromium policy definition: WebRtcIPHandling](https://chromium.googlesource.com/chromium/src/+/HEAD/components/policy/resources/templates/policy_definitions/WebRtc/WebRtcIPHandling.yaml)
- [RFC 8828: WebRTC IP Address Handling Requirements, section 5.2](https://www.rfc-editor.org/rfc/rfc8828.html#section-5.2)
- [RFC 1929: Username/Password Authentication for SOCKS V5](https://www.rfc-editor.org/rfc/rfc1929.html)
- [RFC 9110: 407 Proxy Authentication Required](https://www.rfc-editor.org/rfc/rfc9110.html#name-407-proxy-authentication-re)
- [RFC 6888: Common Requirements for Carrier-Grade NATs](https://www.rfc-editor.org/rfc/rfc6888.html)
- [RFC 5737: IPv4 Address Blocks Reserved for Documentation](https://www.rfc-editor.org/rfc/rfc5737.html)
- [pproxy (python-proxy)](https://github.com/qwj/python-proxy)

## Guías relacionadas

- [Configurar un proxy en Playwright](https://ipvolt.com/es/guides/playwright-proxy-setup.md)
- [Proxies rotativos vs persistentes: planifica la continuidad](https://ipvolt.com/es/guides/rotating-vs-sticky-proxies.md)
- [Proxies móviles vs residenciales: evalúa con criterio](https://ipvolt.com/es/guides/mobile-vs-residential-proxies.md)

## Sobre ipvolt

Los ejemplos usan configuraciones de proxy genéricas, con enlaces a la documentación técnica original. El comportamiento específico de cada producto debe comprobarse con tu proveedor. ipvolt vende proxies móviles y proxies residenciales desde US$0.60/GB.

[Leer el original en inglés](https://ipvolt.com/guides/browser-use-proxy-setup.md)

**Conecta tu primer proxy.**

Móvil desde US$9 al día. Residencial desde US$0.60 por GB, en paquetes desde US$5.

[Comprar un proxy móvil](https://ipvolt.com/dashboard/mobile)

[Comprar proxies residenciales](https://ipvolt.com/dashboard/residential)

