# Exemplos de código de proxy de datacenter: curl, Python, Node.js e Playwright

> Exemplos de código de proxy para curl, Python requests e aiohttp, Node.js undici e Playwright, HTTP e SOCKS5. RackProxies: a partir de US$ 1,29 por IP, sem KYC, cripto.

- URL: https://rackproxies.com/pt/docs/code-examples/
- Última atualização: 2026-10-19
- Publisher: RackProxies (https://rackproxies.com)

Snippets prontos para copiar para os clientes mais comuns, cada um testado quanto à sintaxe. Todos os exemplos apontam para api.ipify.org, httpbin.org/ip ou example.com.

**Resposta rápida — Como uso um proxy de datacenter no código?**

Estes exemplos de código de proxy passam uma URL `http://USERNAME:PASSWORD@IP:PORT` para o seu cliente: `-x` no curl, `proxies=` no Python requests, um `ProxyAgent` no Node.js, uma opção `proxy` no Playwright. O SOCKS5 usa `socks5h://`. Os IPs da **RackProxies** suportam HTTP, HTTPS (CONNECT) e SOCKS5, a partir de US$ 1,29 por IPv4 dedicado por 30 dias. Sem KYC, somente cripto.

## Qual snippet eu preciso?

*Endereço de documentação 203.0.113.24 e porta 8000 em todos os snippets: substitua-os por uma linha da sua conta.*

| Cliente | Proxy HTTP | Proxy SOCKS5 | Pacote extra |
| --- | --- | --- | --- |
| curl | `-x http://…` | `-x socks5h://…` | Nenhum |
| Python requests | `proxies={…}` | URL `socks5h://` | `requests[socks]` para SOCKS5 |
| Python aiohttp | `proxy=` e `proxy_auth=` | Não incluído | `aiohttp-socks` para SOCKS5 |
| Node.js fetch | undici `ProxyAgent` | Não incluído | `undici` |
| Node.js https | `https-proxy-agent` | `socks-proxy-agent` | Um dos dois |
| Playwright | `proxy: { server, username, password }` | Use HTTP ou a allowlist | `playwright` |

## Como uso o proxy com curl?

Passe a URL do proxy com `-x`. O curl cuida do túnel CONNECT para alvos `https://` sozinho. Todos os snippets desta página usam o endereço de documentação `203.0.113.24`; a página [formato de conexão](https://rackproxies.com/pt/docs/connection-format/) mostra como montar a URL a partir da sua linha.

*curl: HTTP, SOCKS5, login separado, allowlist*

```bash
# HTTP proxy, HTTPS target (CONNECT tunnel)
curl -x http://USERNAME:PASSWORD@203.0.113.24:8000 https://api.ipify.org

# SOCKS5, hostname resolved by the proxy
curl -x socks5h://USERNAME:PASSWORD@203.0.113.24:8000 https://api.ipify.org

# Login passed separately (no URL-encoding needed)
curl -x http://203.0.113.24:8000 -U 'USERNAME:PASSWORD' https://httpbin.org/ip

# IP allowlist: no login
curl -x http://203.0.113.24:8000 https://api.ipify.org

# Show the proxy handshake and the timings
curl -v -s -o /dev/null -w '%{time_connect} %{time_appconnect} %{time_total}\n' \
  -x http://USERNAME:PASSWORD@203.0.113.24:8000 https://example.com
```

## Como uso o proxy com Python requests?

Passe ao requests um dicionário `proxies` com a mesma URL para `http` e `https`. A chave `https` é a usada para alvos `https://`; seu valor ainda começa com `http://` porque descreve a conexão com o proxy. O requests gera `ProxyError` quando o proxy recusa a conexão ou o login.

*requests via proxy HTTP, com tratamento de erros*

```python
import requests  # pip install requests

# From the line 203.0.113.24:8000:USERNAME:PASSWORD in your account
proxy = 'http://USERNAME:PASSWORD@203.0.113.24:8000'
proxies = {'http': proxy, 'https': proxy}

try:
    response = requests.get('https://api.ipify.org', proxies=proxies, timeout=20)
    response.raise_for_status()
    print('Exit IP:', response.text)
except requests.exceptions.ProxyError as error:
    print('Proxy problem (credentials, port or allowlist):', error)
except requests.exceptions.Timeout:
    print('No answer within 20 seconds')
```

*requisições via SOCKS5 (pip install "requests[socks]")*

```python
import requests  # pip install "requests[socks]"

# socks5h: the proxy resolves the hostname. Use the SOCKS5 port shown in your account.
proxy = 'socks5h://USERNAME:PASSWORD@203.0.113.24:8000'
proxies = {'http': proxy, 'https': proxy}

response = requests.get('https://httpbin.org/ip', proxies=proxies, timeout=20)
print(response.json())  # {'origin': '203.0.113.24'}
```

*Uma sessão para muitas requisições por meio de um mesmo IP*

```python
import requests

# A Session reuses connections: faster for many requests through the same IP.
session = requests.Session()
session.proxies.update({
    'http': 'http://USERNAME:PASSWORD@203.0.113.24:8000',
    'https': 'http://USERNAME:PASSWORD@203.0.113.24:8000',
})
session.headers['User-Agent'] = 'my-monitor/1.0 (contact: you@example.com)'

for url in ['https://example.com', 'https://httpbin.org/ip']:
    response = session.get(url, timeout=20)
    print(url, response.status_code, len(response.content), 'bytes')
```

Defina um `User-Agent` que identifique sua ferramenta e um contato, como no exemplo da sessão: assim os donos de sites podem falar com você em vez de bloquear você. O requests também lê as variáveis de ambiente `HTTP_PROXY` e `HTTPS_PROXY` quando nenhum argumento `proxies` é informado.

## Como uso o proxy com Python aiohttp?

O aiohttp recebe o proxy por requisição: `proxy=` para o endereço e `proxy_auth=` para o login. Ele aceita proxies HTTP, incluindo CONNECT para destinos `https://`. Para SOCKS5, precisa do pacote separado `aiohttp-socks`.

*aiohttp por um proxy HTTP*

```python
import asyncio

import aiohttp  # pip install aiohttp (HTTP proxies; SOCKS needs the aiohttp-socks package)

PROXY = 'http://203.0.113.24:8000'
AUTH = aiohttp.BasicAuth('USERNAME', 'PASSWORD')


async def main():
    timeout = aiohttp.ClientTimeout(total=20)
    async with aiohttp.ClientSession(timeout=timeout) as session:
        async with session.get('https://httpbin.org/ip', proxy=PROXY, proxy_auth=AUTH) as response:
            print(await response.json())


asyncio.run(main())
```

## Como uso o proxy com Node.js?

O `fetch` nativo do Node não aceita argumento de proxy, então use o pacote `undici` e o seu `ProxyAgent` como o `dispatcher`. Para o módulo clássico `https`, use `https-proxy-agent` para proxies HTTP e `socks-proxy-agent` para SOCKS5. Os dois trechos são módulos ES: salve-os como arquivos `.mjs`.

*fetch com undici ProxyAgent*

```javascript
// npm install undici
import { ProxyAgent, fetch } from 'undici';

const dispatcher = new ProxyAgent({
  uri: 'http://203.0.113.24:8000',
  token: `Basic ${Buffer.from('USERNAME:PASSWORD').toString('base64')}`,
});

const response = await fetch('https://api.ipify.org', { dispatcher });
console.log('Exit IP:', await response.text());
```

*https com https-proxy-agent e socks-proxy-agent*

```javascript
// npm install https-proxy-agent socks-proxy-agent
import https from 'node:https';
import { HttpsProxyAgent } from 'https-proxy-agent';
import { SocksProxyAgent } from 'socks-proxy-agent';

const httpAgent = new HttpsProxyAgent('http://USERNAME:PASSWORD@203.0.113.24:8000');
// Use the SOCKS5 port shown in your account; socks5h lets the proxy resolve DNS.
const socksAgent = new SocksProxyAgent('socks5h://USERNAME:PASSWORD@203.0.113.24:8000');

for (const agent of [httpAgent, socksAgent]) {
  https.get('https://api.ipify.org', { agent }, (res) => {
    res.setEncoding('utf8');
    res.on('data', (chunk) => console.log('Exit IP:', chunk));
  }).on('error', (err) => console.error('Proxy error:', err.message));
}
```

## Como uso o proxy com Playwright?

Passe um objeto `proxy` para `chromium.launch()` com o servidor e, separadamente, o usuário e a senha. Use o formato HTTP: o cliente SOCKS5 nativo do Chromium historicamente não suporta autenticação de usuário e senha para proxies SOCKS5. Com a lista de IPs permitidos, omita `username` e `password`.

*Playwright (Chromium) por um proxy HTTP*

```javascript
// npm install playwright && npx playwright install chromium
import { chromium } from 'playwright';

const browser = await chromium.launch({
  proxy: { server: 'http://203.0.113.24:8000', username: 'USERNAME', password: 'PASSWORD' },
});
const page = await browser.newPage();
await page.goto('https://api.ipify.org');
console.log('Exit IP:', await page.textContent('body'));
await browser.close();
```

Use navegadores através de um proxy para QA dos seus próprios sites, verificações de anúncios e de localização e tarefas legais semelhantes. Lembre-se de que o proxy muda apenas o IP: o idioma e o fuso horário do navegador continuam os da sua máquina, a menos que você os defina no contexto do navegador.

## Como meço a latência através de um proxy?

Cronometre algumas requisições completas e use a mediana. O trecho Python abaixo envia cinco requisições para `https://example.com` por um mesmo IP. Execute-o por IPs de diferentes cidades de datacenter para compará-las; o [guia de cidades](https://rackproxies.com/pt/guides/choose-a-datacenter-city/) explica o piso físico de cada distância.

*Tempo mediano de requisição através de um proxy*

```python
import statistics
import time

import requests

proxy = 'http://USERNAME:PASSWORD@203.0.113.24:8000'
timings = []
for _ in range(5):
    start = time.perf_counter()
    requests.get('https://example.com', proxies={'http': proxy, 'https': proxy}, timeout=20)
    timings.append((time.perf_counter() - start) * 1000)

print(f'median {statistics.median(timings):.0f} ms over {len(timings)} requests')
```

## Como uso uma lista inteira de IPs?

Carregue seu export TXT, converta cada linha em uma URL e escolha um IP por requisição: rodízio entre sites, ou o mesmo IP para o mesmo site. O [guia de rotação vs estático](https://rackproxies.com/pt/guides/rotating-vs-static-datacenter-proxies/) tem um exemplo completo, e a página do [formato de conexão](https://rackproxies.com/pt/docs/connection-format/) tem um conversor para a lista inteira. Respeite o ritmo de cada site qualquer que seja o tamanho da sua lista: mais IPs não aumentam o limite de um site.

## Perguntas sobre exemplos de código

### Por que uso http:// para o proxy quando o site é https://?

O esquema da URL do proxy descreve sua conexão com o proxy, não com o site. Seu cliente se conecta ao proxy por TCP simples, pede que ele abra um túnel CONNECT e então executa o TLS com o site dentro dele. O conteúdo da página permanece criptografado de ponta a ponta; apenas o login do proxy trafega de forma legível.

### Minha senha tem caracteres especiais. O que muda?

No formato de URL, codifique a senha com `urllib.parse.quote(password, safe='')` em Python ou `encodeURIComponent(password)` em JavaScript. Clientes que recebem o login separadamente, como o `BasicAuth` do aiohttp, as `username` e `password` do Playwright, ou o `-U` do curl, não precisam de codificação. A página do [formato de conexão](https://rackproxies.com/pt/docs/connection-format/) lista os caracteres.

### Por que o requests diz que faltam dependências para suporte a SOCKS?

O suporte a SOCKS do requests fica em um extra opcional. Instale-o com `pip install "requests[socks]"`, que adiciona o PySocks, e use uma URL `socks5h://` para que o proxy resolva os hostnames. Proxies HTTP funcionam sem nenhum pacote extra, então você também pode trocar a URL para `http://` e manter suas dependências inalteradas.

### Posso executar muitas requisições em paralelo por um mesmo IP?

Sim, dentro do uso justo; não publicamos um limite de conexões por IP. Mantenha o paralelismo razoável para sua própria estabilidade e respeite o ritmo de cada site: requisições paralelas ao mesmo site continuam contando contra os limites dele. Cobrado por IP por 30 dias, não por GB, sob uma política de uso justo.

### Qual URL de teste meu código deve chamar primeiro?

Chame `https://api.ipify.org` ou `https://httpbin.org/ip`: cada uma retorna o IP que vê, então você confirma que o tráfego sai pelo seu proxy. Depois chame seu alvo real. Se a URL de teste funciona e o alvo não, o problema está entre o proxy e o alvo, não no seu código.

### Preciso de documento para obter os proxies destes exemplos?

Não. Sem KYC: sem documento, sem selfie, sem documentos para se cadastrar, recarregar ou comprar. Adicione saldo em BTC, USDT, USDC, ETH, SOL, LTC, compre um plano em US$ 1,29 e copie as linhas da sua conta para os trechos. Veja [preços](https://rackproxies.com/pt/pricing/) para todos os tamanhos de plano.

**Execute os exemplos com seu próprio IP** 1 IP para US$ 1,29, HTTP e SOCKS5 incluídos. Sem KYC, pagar com cripto. [Ver preços](https://rackproxies.com/pt/pricing/) · [Início rápido](https://rackproxies.com/pt/docs/quickstart/)

## Referências

1. [manual do curl](https://curl.se/docs/manpage.html) — curl project (2026-10-19)
2. [Requests: Proxies e SOCKS](https://requests.readthedocs.io/en/latest/user/advanced/) — Requests (2026-10-19)
3. [aiohttp: Suporte a proxy](https://docs.aiohttp.org/en/stable/client_advanced.html) — aiohttp (2026-10-19)
4. [undici: ProxyAgent](https://undici.nodejs.org/) — Node.js (2026-10-19)
5. [proxy-agents (https-proxy-agent, socks-proxy-agent)](https://github.com/TooTallNate/proxy-agents) — GitHub (2026-10-19)
6. [Playwright: proxy HTTP](https://playwright.dev/docs/network) — Playwright (2026-10-19)

---

RackProxies: A RackProxies é uma provedora de proxies de datacenter dedicados: endereços IPv4 alugados por IP por 30 dias, pagos com cripto sem envio de documento. As páginas cobrem 22 países e 34 cidades de datacenter com dados públicos de rede.