# Configuração de proxy Playwright com IPs residenciais rotativos (Python e Node.js)

> Configuração de proxy Playwright em Python e Node.js: proxies residenciais autenticados por navegador ou contexto, sessões fixas, páginas leves.

- URL: https://crawlrelay.com/pt/docs/playwright/
- Última atualização: 2026-10-13
- Publisher: CrawlRelay (https://crawlrelay.com)

Forneça o proxy no lançamento para uma saída por navegador, ou por contexto para um país ou uma sessão sticky por contexto. Então corte o tráfego bloqueando o que você não precisa.

**Resposta rápida — Como uso um proxy autenticado no Playwright?**

Passe um objeto `proxy` com `server`, `username` e `password` para `launch()` ou para `new_context()`: `server` é `http://gw.crawlrelay.com:7777`, e as credenciais vão em seus próprios campos, nunca na URL do servidor. Com proxies **CrawlRelay** residenciais, coloque o país e um ID de sessão no nome de usuário para dar a cada contexto sua própria saída. O tráfego custa US$ 0,50/GB a partir de 50 GB. Pago em cripto, sem KYC.

## Configuração do Playwright rapidamente

| Atributo | Valor |
| --- | --- |
| Opção de proxy | `{"server": "http://gw.crawlrelay.com:7777", "username": ..., "password": ...}` |
| Onde | `launch(proxy=...)` para o navegador inteiro, ou `new_context(proxy=...)` por contexto |
| Porta | Porta HTTP 7777; sites HTTPS passam por CONNECT |
| SOCKS5 | Chromium não suporta autenticação SOCKS5: use a porta HTTP |
| Um IP por contexto | `-session-<id>-ttl-<minutes>` no nome de usuário do contexto |
| Custo típico da página | Cerca de 2 MB com cada recurso; algumas centenas de KB com imagens, fontes e mídia bloqueadas |

## Como dou a cada contexto de navegador seu próprio país ou sessão?

Crie um contexto por país ou por sessão sticky. Contextos são baratos comparados a navegadores, e cada um mantém seus próprios cookies, armazenamento e credenciais de proxy. Combine o locale do contexto com o país de saída para que o site veja um visitante consistente.

*Python (API síncrona): um contexto por país*

```python
from playwright.sync_api import sync_playwright

GATEWAY = "http://gw.crawlrelay.com:7777"
LOCALES = {"us": "en-US", "de": "de-DE", "jp": "ja-JP"}

with sync_playwright() as p:
    browser = p.chromium.launch()
    for country, locale in LOCALES.items():
        context = browser.new_context(
            proxy={"server": GATEWAY, "username": "USERNAME-country-%s" % country, "password": "PASSWORD"},
            locale=locale,
        )
        page = context.new_page()
        page.goto("https://api.ipify.org", wait_until="domcontentloaded")
        print(country, page.inner_text("body"))
        context.close()
    browser.close()
```

## Como configuro o proxy no Playwright para Node.js e corto o tráfego?

A opção tem a mesma forma no Node.js. A maior parte do peso de uma página renderizada são imagens, fontes e mídia: a página mediana pesava 2.164 KB no mobile segundo o HTTP Archive Web Almanac 2025. Se você só precisa de texto e links, aborte essas requisições em um manipulador de rota.

*Node.js: sessão sticky no lançamento, recursos pesados bloqueados*

```javascript
import { chromium } from "playwright";

const browser = await chromium.launch({
  proxy: {
    server: "http://gw.crawlrelay.com:7777",
    username: "USERNAME-country-us-session-pw1-ttl-30",
    password: "PASSWORD",
  },
});
const context = await browser.newContext();
// Images, fonts and media are most of a page's bytes
await context.route("**/*", (route) =>
  ["image", "font", "media"].includes(route.request().resourceType()) ? route.abort() : route.continue()
);
const page = await context.newPage();
const response = await page.goto("https://example.com/", { waitUntil: "domcontentloaded" });
console.log(response.status(), await page.title());
await browser.close();
```

## Como executo muitas páginas em paralelo com asyncio?

Use a API async com um pool fixo de contextos. Cada contexto mantém uma sessão sticky durante sua vida útil, para que um site veja poucos visitantes estáveis em vez de um IP por requisição. Recicle um contexto, com um novo ID de sessão, depois de um número definido de páginas ou após um erro.

*Python (API async): um pool de contextos sticky*

```python
import asyncio
import uuid

from playwright.async_api import async_playwright

GATEWAY = "http://gw.crawlrelay.com:7777"
WORKERS = 4


async def worker(browser, queue):
    session = uuid.uuid4().hex[:10]
    context = await browser.new_context(proxy={
        "server": GATEWAY,
        "username": "USERNAME-country-us-session-%s-ttl-30" % session,
        "password": "PASSWORD",
    })
    page = await context.new_page()
    while not queue.empty():
        url = await queue.get()
        try:
            response = await page.goto(url, wait_until="domcontentloaded", timeout=45000)
            print(session, url, response.status if response else None)
        except Exception as exc:  # timeouts and network errors: log and move on
            print(session, url, type(exc).__name__)
        finally:
            queue.task_done()
    await context.close()


async def main(urls):
    queue = asyncio.Queue()
    for url in urls:
        queue.put_nowait(url)
    async with async_playwright() as p:
        browser = await p.chromium.launch()
        await asyncio.gather(*(worker(browser, queue) for _ in range(WORKERS)))
        await browser.close()


asyncio.run(main(["https://example.com/", "https://example.org/"]))
```

## Por que recebo ERR_TUNNEL_CONNECTION_FAILED ou ERR_PROXY_CONNECTION_FAILED?

- **net::ERR_TUNNEL_CONNECTION_FAILED** significa que o proxy não aceitou a requisição CONNECT. Na maioria das vezes as credenciais estavam escritas dentro de `server` em vez de `username` e `password`, então o Chromium não enviou nenhuma. Veja [o erro do túnel](https://crawlrelay.com/pt/docs/errors/err-tunnel-connection-failed/).
- **net::ERR_PROXY_CONNECTION_FAILED** significa que o navegador nunca alcançou o gateway: erro de digitação no host ou porta, ou rede que bloqueia a porta. Veja [erro de conexão do proxy](https://crawlrelay.com/pt/docs/errors/err-proxy-connection-failed/).
- **Tempo de espera 30000ms excedido** em `goto` geralmente significa que você espera por `load` ou `networkidle` em uma página que continua carregando rastreadores. Espere por `domcontentloaded` e depois pelo seletor necessário.

## O que um scraper Playwright não deve fazer?

Use Playwright para renderizar páginas públicas que precisam de JavaScript, não para se passar por pessoas. A [Política de Uso Aceitável do CrawlRelay](https://crawlrelay.com/pt/acceptable-use/) proíbe usar navegadores pelo nosso gateway para criar contas em massa, tomar contas, resolver CAPTCHA automaticamente ou burlar bloqueios deliberados de um site. Não documentamos plugins stealth ou spoofing de fingerprint. Se um site desafiar seu navegador, desacelere, cheque seu robots.txt e termos, e peça acesso ou use sua API.

## Playwright e proxies: perguntas

### Posso usar um proxy diferente para cada contexto do Playwright?

Sim. Passe `proxy` para `browser.new_context()` em Python ou `browser.newContext()` em Node.js. Cada contexto então tem sua própria saída, cookies e armazenamento. Releases muito antigos do Playwright no Windows também exigiam um proxy no lançamento; se você ver esse erro, lance com qualquer proxy placeholder e defina o real por contexto.

### O Playwright suporta proxies SOCKS5 com autenticação?

Não no Chromium, que não suporta autenticação de usuário e senha SOCKS5. Use a porta HTTP do gateway (7777): ela lida com sites HTTPS via túneis CONNECT e suporta usuário e senha em todos os motores de navegador que o Playwright dirige.

### Como checar qual IP e país uma página Playwright usa?

Abra `https://api.ipify.org` no mesmo contexto antes do seu alvo e leia o texto do corpo, como no primeiro exemplo. Lembre que uma sessão sticky mantém aquele IP só enquanto o dispositivo residencial fica online; registre o IP no início de cada contexto para detectar alterações.

### Quanto tráfego uma página Playwright usa através de um proxy?

Tudo é cobrado: HTML, scripts, estilos, imagens, fontes e chamadas API. Uma página completa tem cerca de 2 MB na mediana; bloquear imagens, fontes e mídia geralmente reduz para algumas centenas de kilobytes. Meça suas páginas reais somando tamanhos de resposta em um manipulador `response` para 50 páginas.

### Devo usar navegadores headless ou com interface para scraping?

Headless é a escolha normal para servidores e usa menos recursos. Use navegador com interface só para debugar o que a página mostra. Nenhum muda as regras: renderize páginas públicas numa velocidade educada e respeite o robots.txt e termos do site.

**Renderize páginas públicas através de IPs residenciais** US$ 5,94 para 10 GB, US$ 0,50/GB a partir de 50 GB. [Veja os preços](https://crawlrelay.com/pt/pricing/) · [Guia Puppeteer](https://crawlrelay.com/pt/docs/puppeteer/)

---

CrawlRelay: CrawlRelay é um serviço proxy residencial rotativo e proxies móveis 4G/5G para desenvolvedores, para scrapers e pipelines de dados de IA: tráfego pay-as-you-go que não expira a partir de US$ 0,50/GB, pago com cripto, sem upload de documento. Sem KYC — sem ID, sem selfie, sem documentos. Pague com cripto.