# Integração de Proxy Playwright: Navegador, Contexto e Rotação

Playwright é o único grande framework de navegador onde proxies autenticados funcionam sem problemas — as credenciais são configuradas de forma nativa. A vantagem está nos contextos: um navegador, um IP de saída diferente por tarefa. Aqui está o padrão completo.

Playwright é o único grande framework de automação de navegador onde um proxy autenticado é um recurso de primeira classe: nome de usuário e senha são campos de configuração simples, sem hacks de extensão, sem diálogos de autenticação, sem bibliotecas wrapper. Isso torna a configuração básica do proxy Playwright uma tarefa de cinco linhas em Node ou Python. A verdadeira vantagem está um nível mais profundo — proxies por contexto permitem que um único processo de navegador execute muitas sessões isoladas, cada uma com seu próprio IP de saída, que é a arquitetura de rotação mais econômica que qualquer framework oferece. Este guia cobre ambas as camadas, as armadilhas do SOCKS5 e localhost, o que o proxy faz com sua conta de largura de banda, e onde a furtividade realmente termina.

## Proxy Playwright no lançamento do navegador

Passe um objeto `proxy` para `launch()` e todas as páginas no navegador serão roteadas através dele. Note o formato: a URL do servidor não carrega credenciais — elas vão em campos separados `username` e `password`, que é como o Playwright evita o problema de pop-up de autenticação que aflige o Selenium e o Puppeteer:

```js
const { chromium } = require('playwright');

(async () => {
  const browser = await chromium.launch({
    proxy: {
      server: 'http://residentialpremium.quantumproxies.io:8080',
      username: 'USER',
      password: 'PASS',
    },
  });
  const page = await browser.newPage();
  await page.goto('https://httpbin.org/ip');
  console.log(await page.textContent('body')); // proxy exit IP
  await browser.close();
})();
```

A API Python espelha isso exatamente:

```python
from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(proxy={
        "server": "http://residentialpremium.quantumproxies.io:8080",
        "username": "USER",
        "password": "PASS",
    })
    page = browser.new_page()
    page.goto("https://httpbin.org/ip")
    print(page.text_content("body"))
    browser.close()
```

Se suas credenciais estiverem em uma string padrão `http://user:pass@host:port`, divida-a com a classe URL (`new URL()` em Node, `urllib.parse` em Python) em vez de manipulação de strings — senhas com caracteres especiais sobrevivem dessa forma. Um aviso para testadores: `use.proxy` em `playwright.config.ts` cobre testes, mas há relatos antigos de configurações de proxy no nível de configuração sendo ignoradas em configurações mistas, então para scripts de scraping sempre defina o proxy em `launch()` ou diretamente no contexto.

## Proxies por contexto: rotação sem novos navegadores

Um `BrowserContext` é um navegador isolado dentro do navegador: cookies, armazenamento e cache separados, compartilhando apenas o processo. Contextos aceitam sua própria opção `proxy`, e criar um leva milissegundos em comparação a segundos para um lançamento completo — então o padrão de rotação é um navegador, contexto por tarefa:

```js
const { chromium } = require('playwright');

const PROXY = {
  server: 'http://residentialpremium.quantumproxies.io:8080',
  username: 'USER',
  password: 'PASS',
};

(async () => {
  const browser = await chromium.launch();
  const urls = ['https://example.com/a', 'https://example.com/b'];

  for (const url of urls) {
    const context = await browser.newContext({ proxy: PROXY });
    const page = await context.newPage();
    try {
      await page.goto(url, { timeout: 30000 });
      // ...extract...
    } finally {
      await context.close(); // frees cookies, cache, session
    }
  }
  await browser.close();
})();
```

Apontado para um gateway rotativo, cada contexto sai de um IP diferente em um pool residencial de mais de 90 milhões sem qualquer gerenciamento de lista — é isso que os [proxies rotativos](https://quantumproxies.io/rotating-proxies) fazem no lado do servidor. Quando uma tarefa precisa do mesmo IP em várias páginas (login mais checkout), solicite uma sessão fixa via parâmetros de nome de usuário e a saída será mantida durante a janela da sessão. Contextos também isolam falhas: uma saída banida morre com seu contexto em vez de contaminar todo o navegador.

O mesmo padrão oferece geodirecionamento gratuitamente. Como o proxy é uma opção de contexto, um navegador pode manter um contexto dos EUA, um contexto alemão e um contexto japonês simultaneamente — cada um vendo preços localizados, resultados de busca e banners de consentimento de um IP de saída local. Para trabalho de comparação de preços e verificação de anúncios, isso substitui três regiões de nuvem por três linhas de configuração.

![Um processo de navegador do Playwright contém três contextos isolados, um dos EUA, um alemão e um japonês, cada um roteado por seu próprio IP de saída residencial até o mesmo site. O quadro: mesmo processo, cookies e armazenamento separados, um proxy por newContext, e um contexto custa milissegundos onde um navegador custa segundos.](https://res.cloudinary.com/dmqliab0t/image/upload/f_auto,q_auto,w_1200/v1785335143/blog/generated/qp-b9-004-diag1.png)
*Contextos são a unidade de rotação do Playwright: mesmo processo, identidade separada, próprio proxy. Iniciar um contexto custa milissegundos; um navegador custa segundos.*

## SOCKS5, regras de bypass e a armadilha do localhost

- **SOCKS5 funciona, autenticação SOCKS5 não.** O Chromium não tem suporte para credenciais SOCKS, então `server: 'socks5://...'` conecta apenas a endpoints não autenticados. Com proxies SOCKS5 autenticados, mude para a porta HTTP do mesmo gateway ou coloque o IP da sua máquina na lista branca para que não sejam necessárias credenciais.
- **Hosts de bypass** com `bypass: '*.internal.example.com, localhost'` — o tráfego para esses hosts vai direto. Útil quando seu script também fala com serviços internos que não devem transitar pelo proxy.
- **Localhost é especial.** O Chromium ignora proxies para endereços de loopback por padrão, então testar contra um servidor mock local parece 'ignorar' seu proxy. Isso é o navegador, não o Playwright — teste contra um endpoint externo como httpbin.org/ip em vez disso.
- **Checklist de 'proxy não funcionando':** credenciais nos campos (não na URL do servidor), esquema presente no valor do servidor, e a saída verificada carregando uma página de eco de IP antes de culpar o site de destino.

## Reduza a largura de banda antes de escalar

Um navegador de renderização baixa tudo — imagens, fontes, análises, scripts de anúncios — e através do tráfego residencial medido você paga por tudo isso. Bloquear tipos de recursos não essenciais rotineiramente reduz a transferência por página pela metade ou mais, e o roteamento do Playwright torna isso uma linha única no contexto. Mais padrões em nosso guia para [reduzir custos de largura de banda de proxy](https://quantumproxies.io/blog/reduce-proxy-bandwidth-costs-scraping):

```js
await context.route('**/*', (route) => {
  const type = route.request().resourceType();
  if (type === 'image' || type === 'font' || type === 'media') {
    return route.abort();
  }
  return route.continue();
});
```

Meça o efeito em vez de assumi-lo: assine os eventos de resposta do contexto, some os tamanhos de transferência para uma amostra de páginas com e sem a rota, e você obterá seu custo real por página em GB — o número que decide se um rastreamento de um milhão de páginas é um erro de arredondamento ou uma linha de orçamento.

## Limites de furtividade: o que um proxy não pode corrigir

Seja honesto sobre o limite. Uma saída residencial resolve a reputação de IP — o primeiro e maior filtro — mas o Playwright ainda apresenta sinais de automação acima da camada de rede: peculiaridades de renderização sem cabeça, artefatos CDP e superfícies de impressão digital que fornecedores anti-bot sondam diretamente. Plugins de furtividade corrigem alguns sinais e ficam atrás das atualizações de detectores em outros; é uma corrida armamentista que você herda, não uma configuração que você ativa. A divisão pragmática: execute o Playwright através de [proxies residenciais](https://quantumproxies.io/residential-proxies) para o longo rabo de sites normais, e roteie os domínios genuinamente hostis através de uma [Scraper API](https://quantumproxies.io/scraper-api) que gerencia impressões digitais, renderização e tentativas como seu trabalho completo e devolve HTML, markdown ou JSON estruturado. Seu código Playwright continua fazendo o que é exclusivamente bom — fluxos de interação — enquanto trabalhos de busca e análise se movem para a API. O mesmo cálculo se aplica ao [Puppeteer](https://quantumproxies.io/blog/puppeteer-proxy-setup) e ao [Selenium](https://quantumproxies.io/blog/selenium-proxy-setup-authenticated); nenhuma troca de framework corrige um problema de impressão digital.

![Uma escala que vai de sites normais a domínios hostis: um proxy residencial ultrapassa a primeira parede, a reputação de IP; plugins de stealth ficam atrás das atualizações dos detectores nas verificações de impressão digital; uma Scraper API cuida da segunda parede nos domínios hostis. O quadro: mantenha o Playwright em IPs residenciais e passe os domínios mais difíceis pela API.](https://res.cloudinary.com/dmqliab0t/image/upload/f_auto,q_auto,w_1200/v1785335143/blog/generated/qp-b9-004-diag2.png)
*IPs limpos te levam através da primeira parede. Verificações de impressão digital são a segunda — e o ponto onde uma API supera outro patch de furtividade.*

## Perguntas frequentes

### Como configuro um proxy no Playwright Python?

Passe um dicionário de proxy para `launch()`: `p.chromium.launch(proxy={"server": "http://host:port", "username": "USER", "password": "PASS"})`. O mesmo dicionário funciona em `browser.new_context()` para roteamento por contexto. Credenciais sempre vão nos campos separados, nunca dentro da URL do servidor.

### O Playwright pode usar um proxy diferente por contexto?

Sim — passe uma opção `proxy` para cada chamada `newContext()`. Contextos não compartilham nada além do processo do navegador, então dois contextos com proxies diferentes se comportam como dois navegadores não relacionados para sites de destino. Este é o padrão de rotação padrão: um lançamento, depois um novo contexto por tarefa ou por identidade.

### O Playwright suporta autenticação de proxy SOCKS5?

Não. O Playwright passa SOCKS5 para o navegador, e o Chromium não tem mecanismo para credenciais SOCKS, então endpoints SOCKS5 autenticados falham. Use a porta HTTP(S) do mesmo gateway de proxy com campos de nome de usuário e senha, ou autentique por lista branca de IP e mantenha o esquema SOCKS5.

### Qual é o formato correto de proxy Playwright?

Um objeto com um campo `server` (`scheme://host:port` — http, https ou socks5) além de campos opcionais `username`, `password` e `bypass`. Não coloque credenciais dentro da URL do servidor; o Playwright espera por elas separadamente, e senhas com caracteres especiais só sobrevivem nos campos dedicados.

### Por que meu proxy Playwright não funciona no localhost?

O Chromium ignora proxies para endereços de loopback por padrão, então solicitações para `localhost` ou `127.0.0.1` vão direto e parecem ignorar sua configuração. Verifique o proxy contra uma URL externa, como httpbin.org/ip. Em configurações de teste, também prefira definir o proxy em `launch()` em vez de depender de opções de arquivo de configuração.

A história de proxy do Playwright é a mais limpa do ecossistema: credenciais como configuração, contextos como a unidade de rotação, roteamento como a válvula de largura de banda. Obtenha a qualidade do IP correta por baixo e o framework desaparece em segundo plano — que é exatamente o que uma boa infraestrutura deve fazer.

[Aponte o Playwright para proxies residenciais](https://quantumproxies.io/residential-proxies)