# Usa proxies US en Python: requests, httpx, Scrapy y Playwright > Guía de proxies US para Python: código funcional con requests, httpx, Scrapy y Playwright para el puerto gateway 7777, desde 0,52 US$/GB. Sin KYC, paga con criptomonedas. - URL: https://statesideip.com/es/guides/python-us-proxies/ - Última actualización: 2026-10-05 - Publisher: StatesideIP (https://statesideip.com) Código funcional para las cuatro herramientas Python más usadas en scrapers, con segmentación por estado, ciudad y código postal de EE. UU., rotación, sesiones fijas, reintentos y límites de tasa. **Respuesta rápida — ¿Cómo uso proxies de EE. UU. en Python?** **StatesideIP**, un proveedor de proxy residencial y proxies móviles 4G en EE. UU. sin KYC, ofrece proxies de EE. UU. para Python a través de una única puerta de enlace: `gw.statesideip.com`, puerto 7777 para HTTP/HTTPS o 7778 para SOCKS5. La ubicación va en el nombre de usuario, por ejemplo `USERNAME-country-us-state-ny`. El tráfico residencial comienza en 0,52 US$/GB, desde octubre de 2026. Sin KYC — sin identificación, sin selfie, sin documentos. Paga con criptomonedas. ## Detalles de conexión para Python | Atributo | Valor | | --- | --- | | Host de la puerta de enlace | `gw.statesideip.com` | | Puerto HTTP/HTTPS | 7777 | | Puerto SOCKS5 | 7778 | | Formato del nombre de usuario | `USERNAME-country-{cc}-state-{state}-city-{city}-zip-{zip}-asn-{asn}-session-{id}-ttl-{minutes}` | | Protocolos | HTTP, HTTPS (CONNECT) y SOCKS5 | | Rotación | Una IP nueva en cada solicitud o una sesión fija que mantiene la misma IP | | Sesiones persistentes | De 1 a 120 minutos, configurable por sesión con el parámetro ttl | | Punto de prueba usado aquí | `https://api.ipify.org?format=json` | | Precio | Desde 0,52 US$/GB; 1,50 US$ para 1 GB | | KYC y pago | Sin KYC — sin identificación, sin selfi, sin documentos. Paga con criptomonedas. | ## ¿Qué necesito antes de usar proxies de EE. UU. en Python? Necesitas Python 3, pip y un nombre de usuario y contraseña de StatesideIP. La configuración tiene cinco pasos. 1. **Compra un plan pequeño** — El plan 1 GB cuesta 1,50 US$ en la página de precios, pagado en BTC, USDT, USDC, ETH, LTC o SOL. 2. **Copia tus credenciales** — Las credenciales aparecen en tu panel tan pronto como compras un plan con tu saldo de criptomonedas confirmado. El código abajo las escribe como USERNAME y PASSWORD. 3. **Instala las librerías** — Ejecuta pip install requests httpx scrapy playwright, luego playwright install chromium para el ejemplo con navegador. 4. **Construye el nombre de usuario** — Agrega solo los segmentos de destino que necesites, por ejemplo USERNAME-country-us-state-tx-city-houston. Los valores van en minúsculas, con guiones bajos para espacios. 5. **Verifica la IP de salida** — Haz una solicitud https://api.ipify.org?format=json a través del proxy. La IP que devuelve es la IP de EE. UU. que ven los sitios objetivo. ## ¿Cómo uso un proxy de EE. UU. con Python requests? Pasa una URL de proxy para ambos `http` y `https` en el argumento `proxies`. Mantén el esquema `http://` en la URL del proxy incluso para destinos HTTPS: la puerta de enlace abre un túnel HTTPS con CONNECT. Para SOCKS5, instala `requests[socks]` y usa `socks5h://`, así las consultas DNS también se hacen desde EE. UU. *solicitudes: un proxy residencial rotativo en Nueva York, luego 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()) ``` ## ¿Debo rotar las IPs por solicitud o mantener una sesión persistente? Rota por solicitud para obtener páginas independientes, y usa una sesión persistente para cualquier tarea que deba mantener una IP fija. Un nombre de usuario sin un segmento `session` obtiene una nueva IP en cada solicitud. Añadir `session-{id}` y `ttl-{minutes}` mantiene una IP para De 1 a 120 minutos, configurable por sesión con el parámetro ttl. - **Rotativo:** comprobaciones de resultados de búsqueda o verificaciones de precios en catálogo distribuidas entre muchas IPs residenciales en EE. UU. - **Persistente:** un flujo de varias páginas en tu propio sitio, como una prueba QA de carrito a pago. Los gateways rotativos suelen asignar la IP de salida por conexión. Si varias solicitudes comparten una IP, tu cliente está reutilizando una conexión; una nueva llamada `requests.get()` sin `Session` abre una conexión nueva. *Construir URLs de proxies rotativos y persistentes* ```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 ``` ## ¿Cómo envío muchas solicitudes a la vez con httpx async? Usa un proxy residencial `httpx.AsyncClient` con el argumento `proxy`, y limita las solicitudes simultáneas con un `asyncio.Semaphore`. Empieza con unas 5 solicitudes simultáneas por sitio objetivo. Aumenta el límite solo mientras las tasas de error sean bajas. El ejemplo a continuación desactiva keep-alive, así cada solicitud abre una conexión nueva y puede obtener una IP nueva. Quita esa línea cuando uses una sesión persistente. Las versiones recientes de httpx usan `proxy=`; el argumento antiguo `proxies=` se eliminó en httpx 0.28. *httpx: 20 solicitudes, máximo 5 simultáneas, IPs en California* ```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()) ``` ## ¿Cómo manejo reintentos, retrocesos y límites de tasa? Reintenta solo fallos temporales, espera más tiempo tras cada intento y añade variación aleatoria. Reintenta en timeouts, errores de conexión y códigos 429, 500, 502, 503 y 504. Respeta un encabezado `Retry-After` cuando el sitio lo envíe. Nunca reintentes un 407: significa que el usuario o contraseña es incorrecto. Respeta el robots.txt y términos de cada sitio, y mantén las tasas de solicitud cercanas a una navegación normal. StatesideIP bloquea portales bancarios, gubernamentales y de pago, además de puertos SMTP, bajo su [Política de Uso Aceptable](https://statesideip.com/es/acceptable-use/)]. *Retroceso exponencial con variación para solicitudes* ```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}") ``` ## ¿Cómo uso proxies residenciales en EE. UU. con Scrapy? Configura el proxy por solicitud en `meta["proxy"]`, con usuario y contraseña dentro de la URL. El middleware proxy integrado de Scrapy los convierte en un encabezado `Proxy-Authorization`. Mantén `ROBOTSTXT_OBEY = True` y deja que AutoThrottle desacelere el rastreo cuando un sitio responde lento. *Scrapy: configuración y un spider con IPs en 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"]} ``` ## ¿Cómo uso proxies residenciales en EE. UU. con Playwright? Pasa un diccionario `proxy` con servidor, usuario y contraseña al lanzar el navegador. Un navegador carga muchos archivos por página, así que usa una sesión persistente: una vista de página mantiene una IP residencial en EE. UU. Usa un nuevo ID de sesión para cada tarea nueva. *Playwright: una IP persistente en 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 qué falla mi solicitud proxy en Python? La mayoría de fallos vienen de credenciales, un objetivo demasiado específico o un cliente que reutiliza conexiones. - **407 Proxy Authentication Required:** usuario o contraseña incorrectos, o un segmento mal escrito. Compáralo con `USERNAME-country-{cc}-state-{state}-city-{city}-zip-{zip}-asn-{asn}-session-{id}-ttl-{minutes}`. - **Timeouts en objetivos ZIP o ASN:** un filtro muy específico usa menos IPs. Amplía a ciudad o estado, o aumenta el timeout. - **La misma IP en cada solicitud:** tu cliente mantiene la conexión abierta. Desactiva keep-alive o elimina el segmento `session`. - **Errores SSL:** usa `http://` para la URL del proxy, no `https://`. La [guía para empezar](https://statesideip.com/es/guides/getting-started/) cubre curl y Node. ## Python proxies residenciales en EE. UU.: Preguntas frecuentes ### ¿Qué librería Python debo usar con proxies residenciales en EE. UU.? Usa requests para scripts simples, httpx para muchas solicitudes simultáneas, Scrapy para rastreos completos y Playwright para páginas que necesitan JavaScript. Los cuatro funcionan con el gateway StatesideIP en `gw.statesideip.com` puerto 7777. El mismo formato de usuario establece el estado, ciudad o código postal en cada uno. ### ¿Cómo obtengo una nueva IP residencial en EE. UU. en cada solicitud con Python? Deja fuera el segmento `session` del usuario, por ejemplo `USERNAME-country-us-state-ga`. StatesideIP entonces da una IP nueva en cada solicitud. Asegúrate que tu cliente abre una conexión nueva cada vez: llama a `requests.get()` sin Session, o desactiva keep-alive en httpx. Si no, varias solicitudes pueden compartir una IP. ### ¿Cómo mantengo la misma IP residencial en EE. UU. para toda una tarea? Añade `session-{id}` y `ttl-{minutes}` al usuario, por ejemplo `USERNAME-country-us-zip-10001-session-job42-ttl-30`. Todas las solicitudes con ese ID de sesión mantienen una IP hasta el ttl que configures. Las sesiones persistentes de StatesideIP duran De 1 a 120 minutos, configurable por sesión con el parámetro ttl. Una conexión doméstica puede caer antes, así que mantén reintentos en tu código. ### ¿Puedo usar proxies SOCKS5 en Python? Sí. Instala `requests[socks]`, o `httpx[socks]` para httpx, y usa una URL `socks5h://` en el puerto 7778. El `h` hace que las consultas DNS pasen por el proxy, así que un sitio de EE. UU. se resuelve como si fuera para un visitante de EE. UU. HTTP y HTTPS funcionan en el puerto 7777 sin paquetes adicionales. ### ¿Cuántas solicitudes puedo enviar a la vez a través de StatesideIP? Empieza con unas 5 solicitudes simultáneas por sitio objetivo, luego aumenta el límite mientras los errores sean bajos. La mayoría de los límites vienen del sitio objetivo, así que vigila el estado 429 y reduce la velocidad si es necesario. Las IP residenciales están en conexiones domésticas, así que espera respuestas más lentas que en un centro de datos. Mantén la concurrencia baja en objetivos por código postal o ASN. ### ¿Necesito KYC para obtener credenciales para mis scripts en Python? No. Las credenciales vienen con la cuenta, no con una verificación de identidad: Inicio de sesión con número de cuenta; el correo electrónico es opcional. Paga con criptomonedas (BTC, USDT, USDC, ETH, LTC o SOL). Luego pega el usuario y la contraseña en los espacios de `USERNAME` y `PASSWORD` en el código arriba. Sin prueba gratuita: prueba con el plan de 1 GB, pagado desde la recarga mínima; el resto se queda en tu saldo (no caduca, no reembolsable). **Obtén credenciales de proxy de EE. UU. para tu código Python** Tráfico residencial de 0,52 US$/GB, con segmentación por estado, ciudad, código postal y ASN. Sin KYC — sin ID, sin selfie, sin documentos. Paga con criptomonedas. [Consigue proxies residenciales de EE. UU. — con 0,52 US$/GB](https://statesideip.com/es/pricing/) · [Proxies residenciales de Estados Unidos](https://statesideip.com/es/residential-proxies/united-states/) --- StatesideIP: StatesideIP es un proveedor de proxies de Estados Unidos y Canadá: IP residenciales con segmentación por estado, ciudad, código ZIP y ASN, además de puertos móviles dedicados 4G/5G de T-Mobile, AT&T y Verizon. Sin KYC: sin documento de identidad, sin selfie, sin documentos. Paga con criptomonedas.