# Use proxies dos EUA em Python: requests, httpx, Scrapy e Playwright > Guia de proxies dos EUA para Python: código funcional para requests, httpx, Scrapy e Playwright na porta gateway 7777, de US$ 0,52/GB. Sem KYC, pagar com cripto. - URL: https://statesideip.com/pt/guides/python-us-proxies/ - Última atualização: 2026-10-05 - Publisher: StatesideIP (https://statesideip.com) Código funcional para as quatro ferramentas Python que a maioria dos scrapers usa, com segmentação por estado, cidade e CEP dos EUA, rotação, sessões fixas, tentativas e limites de taxa. **Resposta rápida — Como usar proxies dos EUA em Python?** **StatesideIP**, um provedor de proxy residencial e proxies móveis 4G dos EUA sem KYC, oferece proxies dos EUA para Python através de um único gateway: `gw.statesideip.com`, porta 7777 para HTTP/HTTPS ou 7778 para SOCKS5. A localização vai no nome de usuário, como `USERNAME-country-us-state-ny`. O tráfego residencial começa em US$ 0,52/GB, a partir de outubro de 2026. Sem KYC — sem ID, sem selfie, sem documentos. Pague com cripto. ## Detalhes de conexão para Python | Atributo | Valor | | --- | --- | | Host do gateway | `gw.statesideip.com` | | Porta HTTP/HTTPS | 7777 | | Porta SOCKS5 | 7778 | | Formato do nome de usuário | `USERNAME-country-{cc}-state-{state}-city-{city}-zip-{zip}-asn-{asn}-session-{id}-ttl-{minutes}` | | Protocolos | HTTP, HTTPS (CONNECT) e SOCKS5 | | Rotação | Um novo IP a cada requisição, ou uma sessão sticky que mantém o mesmo IP | | Sessões persistentes | De 1 a 120 minutos, definido por sessão com o parâmetro ttl | | Endpoint de teste usado aqui | `https://api.ipify.org?format=json` | | Preço | De US$ 0,52/GB; US$ 1,50 por 1 GB | | KYC e pagamento | Sem KYC — sem documento de identidade, sem selfie, sem documentos. Pague com cripto. | ## O que preciso antes de usar proxies dos EUA em Python? Você precisa de Python 3, pip, e um nome de usuário e senha da StatesideIP. A configuração leva cinco passos. 1. **Compre um plano pequeno** — O plano 1 GB custa US$ 1,50 na página de preços, pago em BTC, USDT, USDC, ETH, LTC ou SOL. 2. **Copie suas credenciais** — As credenciais aparecem no seu painel assim que você compra um plano usando seu saldo de cripto confirmado. O código abaixo grava elas como USERNAME e PASSWORD. 3. **Instale as bibliotecas** — Execute pip install requests httpx scrapy playwright, depois playwright install chromium para o exemplo com navegador. 4. **Monte o nome de usuário** — Adicione apenas os segmentos de segmentação que você precisa, por exemplo USERNAME-country-us-state-tx-city-houston. Os valores são em minúsculas, com underscores para espaços. 5. **Verifique o IP de saída** — Faça uma requisição https://api.ipify.org?format=json através do proxy. O IP retornado é o IP dos EUA que os sites-alvo veem. ## Como usar um proxy dos EUA com requests em Python? Passe uma URL de proxy para ambos `http` e `https` no argumento `proxies`. Mantenha o esquema `http://` na URL do proxy mesmo para destinos HTTPS: o gateway abre um túnel HTTPS com CONNECT. Para SOCKS5, instale `requests[socks]` e use `socks5h://`, assim as consultas DNS também ocorrem do lado dos EUA. *requisições: um IP rotativo de Nova York, depois SOCKS5* ```python import requests HOST = "gw.statesideip.com" USER = "USERNAME-country-us-state-ny" # rotating New York State IP PASSWORD = "PASSWORD" proxy = f"http://{USER}:{PASSWORD}@{HOST}:7777" r = requests.get("https://api.ipify.org?format=json", proxies={"http": proxy, "https": proxy}, timeout=30) print(r.json()) # SOCKS5 (pip install "requests[socks]"); socks5h resolves DNS through the proxy socks = f"socks5h://{USER}:{PASSWORD}@{HOST}:7778" r = requests.get("https://api.ipify.org?format=json", proxies={"http": socks, "https": socks}, timeout=30) print(r.json()) ``` ## Devo rotacionar IPs a cada requisição ou manter uma sessão fixa? Rotacione a cada requisição para buscas independentes de páginas e use uma sessão fixa para qualquer tarefa que precise manter um IP. Um nome de usuário sem um segmento `session` recebe um novo IP a cada requisição. Adicionar `session-{id}` e `ttl-{minutes}` mantém um IP para De 1 a 120 minutos, definido por sessão com o parâmetro ttl. - **Rotativo:** verificações de resultados de busca ou checagem de preços em catálogo distribuídas por muitos IPs dos EUA. - **Fixo:** um fluxo de múltiplas páginas no seu próprio site, como um teste QA de carrinho para checkout. Gateways rotativos geralmente atribuem o IP de saída por conexão. Se várias requisições compartilham um IP, seu cliente está reutilizando uma conexão; uma nova chamada `requests.get()` sem `Session` abre uma conexão nova. *Construir URLs de proxy rotativos e fixos* ```python import uuid def proxy_url(state=None, city=None, zip_code=None, session=None, ttl=10): parts = ["USERNAME", "country-us"] if state: parts.append(f"state-{state}") if city: parts.append(f"city-{city}") if zip_code: parts.append(f"zip-{zip_code}") if session: parts += [f"session-{session}", f"ttl-{ttl}"] user = "-".join(parts) return f"http://{user}:PASSWORD@gw.statesideip.com:7777" rotating = proxy_url(state="tx", city="houston") # new IP per request sticky = proxy_url(zip_code="10001", session=uuid.uuid4().hex[:8], ttl=30) # one IP, 30 min ``` ## Como enviar muitas requisições simultâneas com httpx async? Use um único `httpx.AsyncClient` com o argumento `proxy` e limite as requisições em voo com um `asyncio.Semaphore`. Comece com cerca de 5 requisições em voo por site alvo. Aumente o limite somente enquanto a taxa de erros permanecer baixa. O exemplo abaixo desativa keep-alive, assim cada requisição abre uma conexão nova e pode obter um IP novo. Remova essa linha quando usar uma sessão fixa. Versões recentes do httpx aceitam `proxy=`; o argumento antigo `proxies=` foi removido no httpx 0.28. *httpx: 20 requisições, no máximo 5 em voo, IPs da Califórnia* ```python import asyncio import httpx PROXY = "http://USERNAME-country-us-state-ca:PASSWORD@gw.statesideip.com:7777" URLS = ["https://api.ipify.org?format=json"] * 20 async def fetch(client, sem, url): async with sem: # caps requests in flight r = await client.get(url) r.raise_for_status() return r.json() async def main(): sem = asyncio.Semaphore(5) limits = httpx.Limits(max_keepalive_connections=0) # new connection, new IP async with httpx.AsyncClient(proxy=PROXY, limits=limits, timeout=30) as client: results = await asyncio.gather(*(fetch(client, sem, u) for u in URLS), return_exceptions=True) for res in results: print(res) asyncio.run(main()) ``` ## Como lidar com tentativas, backoff e limites de taxa? Tente novamente apenas falhas temporárias, espere mais tempo após cada tentativa e adicione jitter aleatório. Tente novamente em timeouts, erros de conexão e códigos de status 429, 500, 502, 503 e 504. Respeite um cabeçalho `Retry-After` quando o site enviar um. Nunca tente novamente um 407: significa que o nome de usuário ou senha está errado. Respeite o robots.txt e termos de cada site e mantenha as taxas de requisição próximas à navegação normal. StatesideIP bloqueia portais bancários, governamentais e de pagamento, além de portas SMTP, sob sua [Política de Uso Aceitável](https://statesideip.com/pt/acceptable-use/). *Backoff exponencial com jitter para requisições* ```python import random import time import requests RETRY_STATUS = {429, 500, 502, 503, 504} def get_with_retries(url, proxies, attempts=5): for attempt in range(attempts): try: r = requests.get(url, proxies=proxies, timeout=30) if r.status_code == 407: raise RuntimeError("407: check USERNAME and PASSWORD") # do not retry if r.status_code not in RETRY_STATUS: return r ra = r.headers.get("Retry-After", "") wait = int(ra) if ra.isdigit() else 2 ** attempt except (requests.ConnectionError, requests.Timeout): wait = 2 ** attempt time.sleep(wait + random.uniform(0, 1)) # backoff plus jitter raise RuntimeError(f"gave up on {url}") ``` ## Como usar proxies dos EUA no Scrapy? Defina o proxy por requisição em `meta["proxy"]`, com nome de usuário e senha dentro da URL. O middleware de proxy embutido do Scrapy transforma isso em um cabeçalho `Proxy-Authorization`. Mantenha `ROBOTSTXT_OBEY = True` e deixe o AutoThrottle desacelerar o rastreamento quando o site responder lentamente. *Scrapy: configurações e spider com IPs de Miami* ```python # settings.py ROBOTSTXT_OBEY = True CONCURRENT_REQUESTS_PER_DOMAIN = 4 AUTOTHROTTLE_ENABLED = True RETRY_TIMES = 3 RETRY_HTTP_CODES = [429, 500, 502, 503, 504] # spiders/ip_check.py import scrapy PROXY = "http://USERNAME-country-us-state-fl-city-miami:PASSWORD@gw.statesideip.com:7777" class IpCheckSpider(scrapy.Spider): name = "ip_check" start_urls = ["https://api.ipify.org?format=json"] def start_requests(self): for url in self.start_urls: yield scrapy.Request(url, meta={"proxy": PROXY}, dont_filter=True) def parse(self, response): yield {"ip": response.json()["ip"]} ``` ## Como usar proxies dos EUA com Playwright? Passe um dicionário `proxy` com servidor, nome de usuário e senha ao iniciar o navegador. Um navegador carrega muitos arquivos por página, então use uma sessão fixa: uma visualização de página mantém um IP dos EUA. Use um novo ID de sessão para cada nova tarefa. *Playwright: um IP fixo de Chicago por 15 minutos* ```python import asyncio from playwright.async_api import async_playwright async def main(): async with async_playwright() as p: browser = await p.chromium.launch(proxy={ "server": "http://gw.statesideip.com:7777", "username": "USERNAME-country-us-state-il-city-chicago-session-pw1-ttl-15", "password": "PASSWORD", }) page = await browser.new_page() await page.goto("https://api.ipify.org?format=json") print(await page.text_content("body")) await browser.close() asyncio.run(main()) ``` ## Por que minha requisição Python com proxy falha? A maioria das falhas vem de credenciais, alvo muito restrito ou cliente que reutiliza conexões. - **407 Proxy Authentication Required:** nome de usuário ou senha errados, ou segmento escrito errado. Compare com `USERNAME-country-{cc}-state-{state}-city-{city}-zip-{zip}-asn-{asn}-session-{id}-ttl-{minutes}`. - **Timeouts em alvos ZIP ou ASN:** filtro restrito usa menos IPs. Amplie para cidade ou estado, ou aumente o timeout. - **Mesmo IP em todas as requisições:** seu cliente mantém a conexão aberta. Desative keep-alive ou remova o segmento `session`. - **Erros SSL:** use `http://` para a URL do proxy, não `https://`. O [guia de início rápido](https://statesideip.com/pt/guides/getting-started/) cobre curl e Node. ## Proxies dos EUA em Python: FAQ ### Qual biblioteca Python usar com proxies dos EUA? Use requests para scripts simples, httpx para muitas requisições simultâneas, Scrapy para rastreamentos completos e Playwright para páginas que precisam de JavaScript. Todos os quatro funcionam com o gateway StatesideIP em `gw.statesideip.com` na porta 7777. O mesmo formato de nome de usuário define o estado, cidade ou CEP dos EUA em cada um deles. ### Como obter um novo IP dos EUA a cada requisição em Python? Deixe o segmento `session` fora do nome de usuário, por exemplo `USERNAME-country-us-state-ga`. StatesideIP então fornece um IP novo a cada requisição. Certifique-se que seu cliente abre uma conexão nova a cada vez: chame `requests.get()` sem uma Session, ou desative keep-alive no httpx. Caso contrário, várias requisições podem compartilhar um IP. ### Como manter o mesmo IP dos EUA durante toda uma tarefa? Adicione `session-{id}` e `ttl-{minutes}` ao nome de usuário, por exemplo `USERNAME-country-us-zip-10001-session-job42-ttl-30`. Todas as requisições com esse ID de sessão mantêm um IP por até o ttl que você definir. Sessões fixas StatesideIP duram De 1 a 120 minutos, definido por sessão com o parâmetro ttl. Uma conexão residencial ainda pode cair antes, então mantenha tentativas no seu código. ### Posso usar proxies SOCKS5 em Python? Sim. Instale `requests[socks]`, ou `httpx[socks]` para httpx, e use uma URL `socks5h://` na porta 7778. O `h` faz com que as consultas DNS passem pelo proxy, então um site dos EUA é resolvido como se fosse para um visitante dos EUA. HTTP e HTTPS funcionam na porta 7777 sem pacote extra. ### Quantas requisições posso enviar ao mesmo tempo pelo StatesideIP? Comece com cerca de 5 requisições simultâneas por site alvo, depois aumente o limite enquanto os erros permanecerem baixos. A maioria dos limites vem do site alvo, então fique atento ao status 429 e reduza o ritmo. IPs residenciais ficam em conexões domésticas, então espere respostas mais lentas que em datacenters. Mantenha a concorrência menor em alvos por CEP ou ASN. ### Preciso de KYC para obter credenciais para meus scripts Python? Não. As credenciais vêm com a conta, não com uma verificação de identidade: Login com número de conta; e-mail é opcional. Pague com cripto (BTC, USDT, USDC, ETH, LTC ou SOL). Depois cole o nome de usuário e senha nos espaços `USERNAME` e `PASSWORD` no código acima. Sem teste grátis — teste com o plano de 1 GB, pago a partir da recarga mínima; o restante permanece no seu saldo (nunca expira, não reembolsável). **Obtenha credenciais de proxy dos EUA para seu código Python** Tráfego residencial de US$ 0,52/GB, com segmentação por estado, cidade, CEP e ASN. Sem KYC — sem documento, selfie ou comprovação. Pague com cripto. [Obtenha proxies residenciais dos EUA — com US$ 0,52/GB](https://statesideip.com/pt/pricing/) · [Proxies residenciais dos EUA](https://statesideip.com/pt/residential-proxies/united-states/) --- StatesideIP: A StatesideIP é um provedor de proxies dos EUA e Canadá: IPs residenciais com segmentação por estado, cidade, CEP e ASN, além de proxies móveis 4G/5G dedicados da T-Mobile, AT&T e Verizon. Sem KYC — sem documento, sem selfie, sem papéis. Pague com cripto.