GProxy + Python requests — guia completo de integração 2026

TL;DR

Use proxies residenciais, datacenter ou IPv6 da GProxy com a biblioteca requests do Python em 4 linhas de código. Este guia cobre autenticação HTTP/SOCKS5, reuso de sessão, rotação, tratamento de erros e armadilhas comuns — com exemplos prontos para copiar e colar.

Obter proxies → Python requests site →

Idioma: Python Versão: 2.31+

Pré-requisitos

✓Python 3.7 ou mais recente
✓Biblioteca requests instalada (pip install requests)
✓Para SOCKS5: requests[socks] (pip install requests[socks])
✓Conta GProxy com credenciais ativas (residencial, datacenter ou IPv6)

Configuração passo a passo

Instale as dependências

Instale a biblioteca requests. Se você pretende usar proxies SOCKS5, instale o extra socks.

pip install requests
pip install requests[socks]  # para suporte a SOCKS5

Obtenha suas credenciais GProxy

Entre no seu painel GProxy e copie o host do proxy, a porta, o nome de usuário e a senha da página do produto correspondente (Residencial / Premium Datacenter / IPv6).

Use proxy HTTP com autenticação

A forma mais simples. Passe um dict de proxies para o requests. A GProxy usa Basic Auth na URL.

import requests

proxies = {
    'http':  'http://USERNAME:[email protected]:8080',
    'https': 'http://USERNAME:[email protected]:8080',
}

r = requests.get('https://api.ipify.org?format=json', proxies=proxies, timeout=15)
print(r.json())
# {'ip': '<your-proxy-egress-ip>'}

Use proxy SOCKS5

Para SOCKS5, prefixe a URL com socks5h:// (o h significa que a resolução de DNS acontece no lado do proxy — importante para o anonimato).

import requests

proxies = {
    'http':  'socks5h://USERNAME:[email protected]:1080',
    'https': 'socks5h://USERNAME:[email protected]:1080',
}

r = requests.get('https://api.ipify.org?format=json', proxies=proxies, timeout=15)
print(r.json())

Reutilize uma sessão para várias requisições

Para várias requisições através do mesmo proxy (e para manter conexões keep-alive), use uma Session. Isso é drasticamente mais rápido do que criar uma nova requisição a cada vez.

import requests

session = requests.Session()
session.proxies = {
    'http':  'http://USERNAME:[email protected]:8080',
    'https': 'http://USERNAME:[email protected]:8080',
}

for url in ['https://example.com/page1', 'https://example.com/page2']:
    r = session.get(url, timeout=15)
    print(r.status_code, len(r.content))

Rotacione proxies a cada requisição

Para proxies residenciais rotativos ou IPv6, cada nova conexão recebe um IP novo do pool. Use uma lista e escolha aleatoriamente ou em round-robin.

import random
import requests

PROXIES = [
    'http://USERNAME:[email protected]:8001',
    'http://USERNAME:[email protected]:8002',
    'http://USERNAME:[email protected]:8003',
]

def fetch(url):
    proxy_url = random.choice(PROXIES)
    return requests.get(url, proxies={'http': proxy_url, 'https': proxy_url}, timeout=15)

for _ in range(5):
    r = fetch('https://api.ipify.org?format=json')
    print(r.json())

Trate erros e retentativas

Erros de rede e timeouts de proxy acontecem. Envolva as chamadas em try/except e tente de novo com outro proxy. O urllib3.Retry cuida automaticamente das retentativas no nível HTTP.

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

retry_strategy = Retry(
    total=3,
    backoff_factor=1,
    status_forcelist=[429, 500, 502, 503, 504],
    allowed_methods=['GET', 'POST'],
)
adapter = HTTPAdapter(max_retries=retry_strategy)
session = requests.Session()
session.mount('http://', adapter)
session.mount('https://', adapter)
session.proxies = {'http': 'http://USERNAME:[email protected]:8080',
                   'https': 'http://USERNAME:[email protected]:8080'}

try:
    r = session.get('https://example.com', timeout=15)
    r.raise_for_status()
except requests.exceptions.ProxyError:
    print('Proxy failed — rotate to next')
except requests.exceptions.Timeout:
    print('Timeout — increase timeout or change proxy')
except requests.exceptions.RequestException as e:
    print(f'Other error: {e}')

Exemplos de código

Início rápido — 4 linhas · python

import requests
proxies = {'http': 'http://USER:[email protected]:8080',
           'https': 'http://USER:[email protected]:8080'}
print(requests.get('https://api.ipify.org?format=json', proxies=proxies).json())

Assíncrono com httpx (alternativa) · python

import httpx
import asyncio

async def fetch_all(urls):
    async with httpx.AsyncClient(proxy='http://USER:[email protected]:8080') as client:
        return await asyncio.gather(*[client.get(u) for u in urls])

results = asyncio.run(fetch_all(['https://example.com/p1', 'https://example.com/p2']))
for r in results:
    print(r.status_code)

Headers customizados + cookies · python

import requests

session = requests.Session()
session.proxies = {'http': 'http://USER:[email protected]:8080',
                   'https': 'http://USER:[email protected]:8080'}
session.headers.update({
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
    'Accept-Language': 'en-US,en;q=0.9',
})

resp = session.get('https://example.com/login')
# Os cookies persistem entre as requisições automaticamente
resp = session.post('https://example.com/login', data={'user': 'me', 'pass': 'x'})

Por que combinar Python requests com a GProxy?

O requests do Python é a biblioteca HTTP mais instalada do ecossistema — mais de 30 bilhões de downloads no total. Adicionar proxies da GProxy leva 2 linhas de código e destrava todo fluxo de scraping, monitoramento e automação que exige rotação de IP, geo-targeting ou bypass de anti-bot. Este guia é de ponta a ponta: configuração, código, casos extremos e troubleshooting.

HTTP vs SOCKS5 — qual usar?

Para 95% dos casos de uso, HTTP está de bom tamanho e é mais rápido. SOCKS5 ganha quando você precisa de: (a) tráfego UDP (jogos, protocolos próprios), (b) protocolos não-HTTP em geral, ou (c) quer que o DNS seja resolvido pelo proxy (use socks5h:// para isso). A GProxy suporta os dois em todos os produtos — escolha pelo caso de uso.

Sessões sticky explicadas

Por padrão, o residencial rotativo da GProxy troca de IP a cada requisição. Alguns fluxos precisam manter o mesmo IP por alguns minutos (fluxos de login, formulários de várias etapas). Para isso, acrescente um token de sessão ao seu nome de usuário:

USERNAME = 'your_user-session-abc123'  # qualquer string depois de -session- trava o IP por ~30 min

Mesmo ID de sessão = mesmo IP. Mudou o ID = novo IP.

Dicas de desempenho

Use requests.Session. Ele reaproveita conexões TCP e é 5-10x mais rápido para várias requisições ao mesmo host.
Defina um timeout razoável. O padrão é não ter timeout — seu script vai travar para sempre se o proxy estiver lento. Recomendamos 15-30 segundos para residencial.
Não carregue o corpo da resposta se você só precisa do status code. Use stream=True e feche a conexão.
Requisições paralelas — use concurrent.futures.ThreadPoolExecutor para 5-50 conexões simultâneas, ou asyncio + httpx para 100+.

Armadilhas comuns

Erros de SSL em HTTPS através de proxy HTTP. Use verify=True (padrão) — nunca defina False em produção. Se o erro de certificado for especificamente sobre o proxy, confirme que você está usando o hostname correto.
Senha com caracteres especiais. Faça URL-encode da senha antes de colocá-la no dict de proxies: urllib.parse.quote(password, safe='').
O requests não segue as variáveis de ambiente de proxy quando proxies={} é passado. Se quiser configuração vinda do ambiente, use trust_env=True na sessão.

Casos de uso

Web scraping em escala

Combine requests + rotação residencial da GProxy para raspar sites de e-commerce sem banimento de IP.

Distribuição de requisições de API

Use um pool de proxies IPv6 da GProxy para espalhar chamadas de API e evitar limites de taxa por IP.

Monitoramento de SERP

Rotacione entre proxies residenciais em cidades diferentes para acompanhar rankings locais do Google.

Inteligência de preços

Proxies datacenter para crawling de alto volume em páginas de preço sem proteção.

Camada HTTP de sneaker bot

Use proxies ISP estáticos virgens (tier virgin da GProxy, $6.50/IP) nas primeiras tentativas em drops de sneakers.

Health checks de redes sociais

Uma única sessão residencial sticky para verificar a entrega de anúncios em contas com geo-targeting.

Dicas Pro

Use Session, não requests.get() dentro de um loop. Uma única sessão mantém as conexões vivas — economiza 100-500ms por requisição.

Misture sessões sticky e rotativas. Use sticky para fluxos de várias etapas (login → ação → logout) e rotativas para buscas sem estado.

Registre o IP de saída nos erros. Adicione print(requests.get('https://api.ipify.org', proxies=proxies).text) no início de cada scrape para confirmar que a rotação está funcionando.

FAQ

Uso http:// ou https:// no dict de proxies? +

O esquema é o protocolo do proxy, não o do site de destino. Use 'http://' para proxies HTTP (funciona tanto para sites HTTP quanto HTTPS). Use 'socks5://' ou 'socks5h://' para proxies SOCKS5.

Por que usar socks5h:// em vez de socks5://? +

O socks5h envia as consultas de DNS através do proxy (anônimo). O socks5 resolve o DNS localmente e vaza seu servidor DNS real. Para anonimato, sempre socks5h.

Posso usar o mesmo código para proxies residenciais, IPv6 e datacenter? +

Sim. A única coisa que muda é a URL do proxy (hostnames/portas diferentes). Residencial e IPv6 usam rp.gproxy.net; datacenter usa dc.gproxy.net. O formato de autenticação é idêntico.

Como faço a rotação de proxies residenciais? +

Duas opções: (1) Envie cada requisição por uma conexão nova — o residencial rotativo da GProxy entrega um IP novo a cada requisição. (2) Use sessões sticky adicionando um ID de sessão ao seu nome de usuário (USER-session-XXX). O sticky permite manter o mesmo IP por até 30 minutos.

Estou recebendo 407 Proxy Authentication Required. +

Credenciais erradas ou URL de proxy errada. Verifique no seu painel a string exata USERNAME:PASSWORD@host:port. Lembre-se de que caracteres especiais em senhas precisam ser URL-encoded.

Estou recebendo 'Cannot connect to proxy: tunnel connection failed: 502'. +

Ou sua assinatura acabou (confira o saldo no painel) ou você está tentando acessar um alvo bloqueado. Teste primeiro uma URL de destino diferente para isolar o problema.

O requests suporta HTTP/2? +

Não, o requests é apenas HTTP/1.1. Para HTTP/2, use httpx (que funciona com o mesmo formato de URL de proxy) — veja o snippet alternativo acima.