# Proxies Python: requests, httpx, aiohttp e Scrapy

> Use proxies residenciais sem KYC em Python: requests, httpx, aiohttp e Scrapy, SOCKS5, sessões sticky e retries. Porta 7777, pago com cripto.

- URL: https://namelessproxy.com/pt/guides/python-proxies/
- Última atualização: 2026-10-05
- Publisher: Nameless Proxy (https://namelessproxy.com)

Código funcional para os quatro clientes Python mais usados, com um auxiliar que cria URLs de proxy direcionadas e sticky.

**Resposta rápida — Como usar proxies em Python?**

Passe uma URL de proxy como `http://USERNAME-country-ae:PASSWORD@gw.namelessproxy.com:7777` para seu cliente HTTP. **Nameless Proxy**, um provedor de proxy residencial focado em privacidade, sem KYC, funciona com requests, httpx, aiohttp e Scrapy, e com `socks5h://` na porta 7778. O direcionamento fica no nome de usuário. Tráfego residencial começa em US$ 0,53/GB. Sem KYC — sem ID, sem selfie, sem documentos. Pague com cripto.

## Configuração Python em resumo

| Atributo | Valor |
| --- | --- |
| URL do proxy | `http://USER-country-xx:PASS@gw.namelessproxy.com:7777` |
| SOCKS5 | `socks5h://…:7778` com `requests[socks]` |
| requests | `proxies={"http": url, "https": url}` |
| httpx 0.26+ | `httpx.Client(proxy=url)` e `httpx.AsyncClient(proxy=url)` |
| aiohttp | `session.get(url, proxy=proxy_url)` (proxies HTTP) |
| Scrapy | `request.meta["proxy"]`, configurado por um downloader middleware |
| IP sticky | Adicione `-session-{id}-ttl-{minutes}` após a cidade, por até 60 minutos |

## Como usar um proxy com requests?

Forneça ao requests a mesma URL de proxy para as chaves `http` e `https`. Alvos HTTPS passam por um túnel CONNECT, então a conexão TLS fica entre seu script e o site. Sempre defina um timeout.

*requests: uma chamada via IP dos Emirados Árabes Unidos*

```python
# pip install requests
import requests

USERNAME = "USERNAME"   # base proxy username from the client area
PASSWORD = "PASSWORD"   # proxy password (not your account password)
HOST = "gw.namelessproxy.com"
HTTP_PORT = 7777
SOCKS_PORT = 7778

proxy = f"http://{USERNAME}-country-ae:{PASSWORD}@{HOST}:{HTTP_PORT}"
proxies = {"http": proxy, "https": proxy}

r = requests.get("https://api.ipify.org?format=json", proxies=proxies, timeout=30)
print(r.json())   # {'ip': '...'}
```

## Como criar URLs de proxy direcionadas e sticky?

Use um helper para cada biblioteca. O nome de usuário segue `USERNAME-country-{cc}-city-{city}-session-{id}-ttl-{minutes}`, então o helper adiciona partes nessa ordem: país, depois cidade, depois sessão e TTL. Sem uma sessão, você obtém um IP rotativo; com uma, o IP permanece o mesmo enquanto durar o TTL.

*proxy_url(): um lugar para direcionamento*

```python
import uuid

def proxy_url(country, city=None, session=None, ttl=30, scheme="http"):
    """Build a gateway URL. Targeting lives in the username, in this order:
    country -> city -> session -> ttl."""
    user = f"{USERNAME}-country-{country.lower()}"
    if city:
        user += f"-city-{city.lower().replace(' ', '_')}"
        if session:
            user += f"-session-{session}-ttl-{ttl}"
    port = SOCKS_PORT if scheme.startswith("socks") else HTTP_PORT
    return f"{scheme}://{user}:{PASSWORD}@{HOST}:{port}"

def new_session():
    """A fresh session ID = a fresh sticky IP."""
    return uuid.uuid4().hex[:10]

# Rotating IP in Egypt, and a sticky IP in Abu Dhabi for 30 minutes
rotating = proxy_url("eg")
sticky = proxy_url("ae", city="Abu Dhabi", session=new_session(), ttl=30)
```

## Como usar SOCKS5 em Python?

Instale o extra SOCKS e use o esquema `socks5h://`. O `h` faz o proxy resolver nomes de host, então as consultas DNS também saem no país alvo. O simples `socks5://` resolve DNS na sua máquina.

*requests via SOCKS5*

```python
# pip install "requests[socks]"
# socks5h:// = the proxy resolves DNS, so lookups also exit in the target country
proxy = proxy_url("ke", scheme="socks5h")
r = requests.get("https://api.ipify.org", proxies={"http": proxy, "https": proxy}, timeout=30)
print(r.text)
```

## Como faço para tentar novamente requisições falhadas com um novo IP?

Tente novamente em erros de conexão e nas respostas 429 e 5xx, com backoff exponencial e um pequeno atraso aleatório. Com um nome de usuário rotativo, cada nova conexão pode sair de um novo IP, então uma nova tentativa também é um IP novo. Para trabalho fixo, inicie um novo ID de sessão quando um IP falhar.

*Backoff e nova tentativa*

```python
import random
import time

RETRY_STATUS = {429, 500, 502, 503, 504}

def fetch(url, country="ae", attempts=4):
    """Retry with exponential backoff. Each attempt opens a new connection,
    so a rotating username exits from a new IP."""
    for attempt in range(attempts):
        proxy = proxy_url(country)
        try:
            r = requests.get(url, proxies={"http": proxy, "https": proxy}, timeout=30)
            if r.status_code not in RETRY_STATUS:
                return r
        except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
            pass  # ProxyError is a ConnectionError: retry on a new IP
        time.sleep(min(2 ** attempt + random.random(), 30))
    raise RuntimeError(f"Giving up on {url} after {attempts} attempts")
```

## Como usar httpx, sync e async?

Desde o httpx 0.26, um cliente recebe um único argumento `proxy=`; o antigo `proxies=` foi removido na versão 0.28. Um cliente mantém conexões ativas, e requisições numa conexão mantida compartilham o IP de saída. Abra um cliente novo ou use uma sessão fixa de propósito, dependendo do que precisar.

*httpx: cliente fixo e lote async*

```python
# pip install httpx   (0.26 or later: the argument is "proxy", not "proxies")
import asyncio
import httpx

# Sync: one sticky IP in Nairobi for 10 minutes
with httpx.Client(proxy=proxy_url("ke", city="nairobi", session=new_session(), ttl=10), timeout=30) as client:
    print(client.get("https://api.ipify.org").text)

# Async: 20 connections at most, rotating IPs in Nigeria
async def main(urls):
    limits = httpx.Limits(max_connections=20)
    async with httpx.AsyncClient(proxy=proxy_url("ng"), timeout=30, limits=limits) as client:
        results = await asyncio.gather(*(client.get(u) for u in urls), return_exceptions=True)
    for url, res in zip(urls, results):
        print(url, res.status_code if isinstance(res, httpx.Response) else repr(res))

asyncio.run(main(["https://api.ipify.org"] * 5))
```

## Como executar muitas requisições com aiohttp?

aiohttp recebe o proxy por requisição, com as credenciais dentro da URL. Ele suporta apenas proxies HTTP; para SOCKS5 você precisa de um pacote extra como aiohttp-socks. Limite a concorrência com um semáforo: comece com cerca de 10 a 20 requisições paralelas e aumente enquanto a taxa de erro permanecer baixa.

*aiohttp com limite de concorrência*

```python
# pip install aiohttp   (HTTP proxies only; the credentials can sit in the proxy URL)
import asyncio
import aiohttp

async def fetch(session, url, sem):
    async with sem:
        async with session.get(url, proxy=proxy_url("eg")) as r:
            return r.status, await r.text()

async def main(urls):
    sem = asyncio.Semaphore(20)   # concurrency cap
    timeout = aiohttp.ClientTimeout(total=30)
    async with aiohttp.ClientSession(timeout=timeout) as session:
        results = await asyncio.gather(*(fetch(session, u, sem) for u in urls), return_exceptions=True)
    print(results)

asyncio.run(main(["https://api.ipify.org"] * 5))
```

## Como adicionar o proxy ao Scrapy?

Escreva um pequeno downloader middleware que defina `request.meta["proxy"]`. O HttpProxyMiddleware embutido do Scrapy então transforma as credenciais em um cabeçalho `Proxy-Authorization`. Dê ao seu middleware um número abaixo de 750 para que ele execute primeiro. As chaves meta por requisição permitem que uma aranha misture países e sessões fixas.

*middlewares.py*

```python
# myproject/middlewares.py
USERNAME = "USERNAME"
PASSWORD = "PASSWORD"
GATEWAY = "gw.namelessproxy.com:7777"

class NamelessProxyMiddleware:
    """Set the proxy per request from request.meta:
    country (default 'ae'), optional city, optional session + ttl."""

    def process_request(self, request, spider):
        meta = request.meta
        user = f"{USERNAME}-country-{meta.get('country', 'ae')}"
        if meta.get("city"):
            user += f"-city-{meta['city']}"
            if meta.get("session"):
                user += f"-session-{meta['session']}-ttl-{meta.get('ttl', 10)}"
        # Scrapy's HttpProxyMiddleware turns the credentials into Proxy-Authorization
        meta["proxy"] = f"http://{user}:{PASSWORD}@{GATEWAY}"
```

*settings.py*

```python
# myproject/settings.py
DOWNLOADER_MIDDLEWARES = {
    # Below 750 so it runs before Scrapy's built-in HttpProxyMiddleware
    "myproject.middlewares.NamelessProxyMiddleware": 350,
}
CONCURRENT_REQUESTS = 16
DOWNLOAD_TIMEOUT = 30
RETRY_TIMES = 3
RETRY_HTTP_CODES = [429, 500, 502, 503, 504, 408]
AUTOTHROTTLE_ENABLED = True
ROBOTSTXT_OBEY = True

# In a spider:
# yield scrapy.Request(url, meta={"country": "sa", "city": "riyadh", "session": "cart01"})
```

> **Faça scraping com responsabilidade** Colete apenas dados públicos, respeite robots.txt e limites de taxa, e lembre-se que dados pessoais continuam sendo pessoais sob leis como o GDPR. Fraude, credential stuffing e takeover de contas são proibidos pela Política de Uso Aceitável. Mais sobre web scraping com proxies.

## Perguntas frequentes

### Por que recebo 407 ou ProxyError em Python?

Um 407 significa que o gateway rejeitou as credenciais. Verifique o nome de usuário base e a senha do proxy na área do cliente, a ordem das partes do direcionamento e quaisquer caracteres especiais na senha, que devem estar codificados em URL. Um ProxyError sem 407 geralmente significa porta errada ou firewall. Teste a mesma URL com curl no [guia rápido](https://namelessproxy.com/pt/guides/quick-start/).

### Por que meu IP não muda entre requisições?

Seu cliente provavelmente está reutilizando uma conexão mantida ativa. Um `requests.Session`, um cliente httpx ou uma sessão aiohttp mantém conexões abertas, e uma conexão mantém um IP de saída. Para um IP novo por requisição, chame `requests.get` sem sessão ou abra um cliente novo. Se você adicionou um ID de sessão, o IP é fixo de propósito.

### Devo usar requests, httpx ou aiohttp?

Use requests para scripts simples e trabalhos pequenos. Use httpx quando quiser uma biblioteca para código sync e async, ou HTTP/2. Use aiohttp para grandes crawls async onde você controla a concorrência. Use Scrapy quando precisar de um crawler completo com agendamento, retries e pipelines. Todos os quatro funcionam com a mesma URL de proxy.

### Um script pode usar vários países ao mesmo tempo?

Sim. O direcionamento faz parte de cada URL de proxy, então crie uma URL diferente por requisição ou por cliente: `proxy_url("ae")` para os Emirados Árabes Unidos e `proxy_url("ng")` para a Nigéria, por exemplo. O tráfego é cobrado do mesmo saldo independentemente do país, e o preço por GB não muda conforme o país.

### Quanto tráfego um scraper usa?

Depende das páginas: uma página HTML costuma ter dezenas a centenas de kilobytes, enquanto imagens e scripts adicionam muito mais. O tráfego é contado em GB decimais (1 GB = 1.000.000.000 bytes), e a área do cliente mostra o uso diário por assinatura e subusuário. Busque apenas o que você vai analisar e pule imagens para reduzir custos.

### O código Python funciona com portas móveis dedicadas?

Sim, com o host, porta, nome de usuário e senha da porta dedicadas da área do cliente em vez dos valores do gateway. O país e a operadora da porta dedicada são escolhidos na hora do aluguel, e você pode mudar depois. Para trocar o IP pelo Python, veja o [guia de rotação de IP móvel](https://namelessproxy.com/pt/guides/rotate-mobile-ip/).

**Execute seu código Python por IPs residenciais** A partir de US$ 0,53/GB, pago com cripto. Sem KYC — sem documento, sem selfie, sem papéis. [Obtenha proxies residenciais — a partir de US$ 0,53/GB](https://namelessproxy.com/pt/pricing/) · [Início rápido](https://namelessproxy.com/pt/guides/quick-start/)

---

Nameless Proxy: Nameless Proxy é um provedor de proxy focado em privacidade e sem KYC: proxies residenciais rotativos e proxies móveis 4G/5G, login por número de conta e pagamento em cripto (Bitcoin, USDT, USDC). Residencial a partir de US$ 0,53/GB.