# Ejemplos de código de proxy de datacenter: curl, Python, Node.js y Playwright

> Ejemplos de código de proxy para curl, Python requests y aiohttp, Node.js undici y Playwright, HTTP y SOCKS5. RackProxies: desde 1,29 US$ por IP, sin KYC, criptomonedas.

- URL: https://rackproxies.com/es/docs/code-examples/
- Última actualización: 2026-10-19
- Publisher: RackProxies (https://rackproxies.com)

Fragmentos listos para copiar para los clientes más comunes, cada uno probado en sintaxis. Todos los ejemplos apuntan a api.ipify.org, httpbin.org/ip o example.com.

**Respuesta rápida — ¿Cómo uso un proxy de datacenter en código?**

Estos ejemplos de código de proxy pasan una URL `http://USERNAME:PASSWORD@IP:PORT` a tu cliente: `-x` en curl, `proxies=` en Python requests, un `ProxyAgent` en Node.js, una opción `proxy` en Playwright. SOCKS5 usa `socks5h://`. Las IPs de **RackProxies** admiten HTTP, HTTPS (CONNECT) y SOCKS5, desde 1,29 US$ por IPv4 dedicada durante 30 días. Sin KYC, solo criptomonedas.

## ¿Qué fragmento necesito?

*Dirección de documentación 203.0.113.24 y puerto 8000 en cada fragmento: reemplázalos por una línea de tu cuenta.*

| Cliente | Proxy HTTP | Proxy SOCKS5 | Paquete extra |
| --- | --- | --- | --- |
| curl | `-x http://…` | `-x socks5h://…` | Ninguno |
| Python requests | `proxies={…}` | URL `socks5h://` | `requests[socks]` para SOCKS5 |
| Python aiohttp | `proxy=` y `proxy_auth=` | No incluido | `aiohttp-socks` para SOCKS5 |
| Node.js fetch | undici `ProxyAgent` | No incluido | `undici` |
| Node.js https | `https-proxy-agent` | `socks-proxy-agent` | Uno de los dos |
| Playwright | `proxy: { server, username, password }` | Usa HTTP o la lista de permitidos | `playwright` |

## ¿Cómo uso el proxy con curl?

Pasa la URL del proxy con `-x`. curl gestiona el túnel CONNECT para destinos `https://` por sí mismo. Todos los fragmentos de esta página usan la dirección de documentación `203.0.113.24`; la página de [formato de conexión](https://rackproxies.com/es/docs/connection-format/) muestra cómo construir la URL a partir de tu línea.

*curl: HTTP, SOCKS5, login aparte, lista de permitidos*

```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
```

## ¿Cómo uso el proxy con Python requests?

Pasa a requests un diccionario `proxies` con la misma URL para `http` y `https`. La clave `https` es la que se usa para destinos `https://`; su valor igualmente empieza por `http://` porque describe la conexión al proxy. requests lanza `ProxyError` cuando el proxy rechaza la conexión o el login.

*requests a través de un proxy HTTP, con manejo de errores*

```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')
```

*solicitudes a través de 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'}
```

*Una sesión para muchas solicitudes a través de una sola 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')
```

Configura un `User-Agent` que nombre tu herramienta y un contacto, como en el ejemplo de Session: así los dueños de los sitios pueden contactarte en lugar de bloquearte. requests también lee las variables de entorno `HTTP_PROXY` y `HTTPS_PROXY` cuando no se pasa el argumento `proxies`.

## ¿Cómo uso el proxy con Python aiohttp?

aiohttp toma el proxy por solicitud: `proxy=` para la dirección y `proxy_auth=` para el login. Admite proxies HTTP, incluido CONNECT para destinos `https://`. Para SOCKS5 necesita el paquete aparte `aiohttp-socks`.

*aiohttp a través de un 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())
```

## ¿Cómo uso el proxy con Node.js?

El módulo integrado `fetch` de Node no acepta un argumento de proxy, así que usa el paquete `undici` y su `ProxyAgent` como `dispatcher`. Para el módulo clásico `https`, usa `https-proxy-agent` para proxies HTTP y `socks-proxy-agent` para SOCKS5. Ambos fragmentos son módulos ES: guárdalos como archivos `.mjs`.

*fetch con 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 con https-proxy-agent y 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));
}
```

## ¿Cómo uso el proxy con Playwright?

Pasa un objeto `proxy` a `chromium.launch()` con el servidor y, por separado, el usuario y la contraseña. Usa el formato HTTP: el cliente SOCKS5 integrado de Chromium históricamente no ha admitido autenticación con usuario y contraseña para proxies SOCKS5. Con la lista de IPs permitidas, omite `username` y `password`.

*Playwright (Chromium) a través de un 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();
```

Usa navegadores a través de un proxy para QA de tus propios sitios, comprobaciones de anuncios y localización y trabajos legales similares. Recuerda que un proxy solo cambia la IP: el idioma y la zona horaria del navegador siguen siendo los de tu máquina a menos que los configures en el contexto del navegador.

## ¿Cómo mido la latencia a través de un proxy?

Mide el tiempo de varias solicitudes completas y quédate con la mediana. El fragmento de Python de abajo envía cinco solicitudes a `https://example.com` a través de una misma IP. Ejecútalo a través de IPs en distintas ciudades de datacenter para compararlas; la [guía de ciudades](https://rackproxies.com/es/guides/choose-a-datacenter-city/) explica el mínimo físico para cada distancia.

*Tiempo de solicitud mediano a través de un 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')
```

## ¿Cómo uso una lista completa de IPs?

Carga tu exportación TXT, convierte cada línea en una URL y elige una IP por solicitud: round-robin entre sitios, o la misma IP para el mismo sitio. La [guía de rotación vs estático](https://rackproxies.com/es/guides/rotating-vs-static-datacenter-proxies/) tiene un ejemplo completo, y la página del [formato de conexión](https://rackproxies.com/es/docs/connection-format/) tiene un conversor para toda la lista. Respeta el ritmo de cada sitio sea cual sea el tamaño de tu lista: más IPs no aumentan el límite de un sitio.

## Preguntas sobre ejemplos de código

### ¿Por qué uso http:// para el proxy cuando el sitio es https://?

El esquema de la URL del proxy describe tu conexión al proxy, no al sitio web. Tu cliente se conecta al proxy por TCP simple, le pide que abra un túnel CONNECT y luego ejecuta TLS con el sitio web dentro de él. El contenido de la página sigue cifrado de extremo a extremo; solo el login del proxy viaja en forma legible.

### Mi contraseña tiene caracteres especiales. ¿Qué cambia?

En formato URL, codifica la contraseña con `urllib.parse.quote(password, safe='')` en Python o `encodeURIComponent(password)` en JavaScript. Los clientes que toman el login por separado, como `BasicAuth` de aiohttp, `username` y `password` de Playwright, o `-U` de curl, no necesitan codificación. La página del [formato de conexión](https://rackproxies.com/es/docs/connection-format/) lista los caracteres.

### ¿Por qué requests dice que le faltan dependencias para el soporte de SOCKS?

El soporte de SOCKS de requests vive en un extra opcional. Instálalo con `pip install "requests[socks]"`, que añade PySocks, y usa una URL `socks5h://` para que el proxy resuelva los nombres de host. Los proxies HTTP funcionan sin ningún paquete extra, así que también puedes cambiar la URL a `http://` y mantener tus dependencias sin cambios.

### ¿Puedo ejecutar muchas solicitudes en paralelo a través de una sola IP?

Sí, dentro del uso justo; no publicamos un límite de conexiones por IP. Mantén el paralelismo razonable para tu propia estabilidad y respeta el ritmo de cada sitio web: las solicitudes en paralelo al mismo sitio siguen contando contra sus límites. Se factura por IP durante 30 días, no por GB, bajo una política de uso razonable.

### ¿Qué URL de prueba debería llamar primero mi código?

Llama a `https://api.ipify.org` o `https://httpbin.org/ip`: cada una devuelve la IP que ve, así puedes confirmar que el tráfico sale desde tu proxy. Luego llama a tu objetivo real. Si la URL de prueba funciona y el objetivo no, el problema está entre el proxy y el objetivo, no en tu código.

### ¿Necesito identificación para obtener los proxies de estos ejemplos?

No. Sin KYC: sin documento de identidad, sin selfie, sin documentos para registrarte, recargar o comprar. Recarga en BTC, USDT, USDC, ETH, SOL, LTC, compra un plan en 1,29 US$ y copia las líneas de tu cuenta en los fragmentos. Consulta [precios](https://rackproxies.com/es/pricing/) para cada tamaño de plan.

**Ejecuta los ejemplos con tu propia IP** 1 IP para 1,29 US$, HTTP y SOCKS5 incluidos. Sin KYC, paga con criptomonedas. [Ver precios](https://rackproxies.com/es/pricing/) · [Inicio rápido](https://rackproxies.com/es/docs/quickstart/)

## Referencias

1. [página de manual de curl](https://curl.se/docs/manpage.html) — curl project (2026-10-19)
2. [Requests: Proxies y SOCKS](https://requests.readthedocs.io/en/latest/user/advanced/) — Requests (2026-10-19)
3. [aiohttp: Soporte de 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: RackProxies es un proveedor de proxies de datacenter dedicados: direcciones IPv4 alquiladas por IP durante 30 días, pagadas con criptomonedas y sin subir documentos de identidad. Las páginas cubren 22 países y 34 ciudades de datacenter con datos públicos de red.