# Guía rápida: conecta con proxies residenciales de Reino Unido y UE en cinco pasos

> Conéctate a proxies residenciales de Reino Unido y UE en PontProxy: gateway, puertos, usuario con targeting, curl, Python, Node.js y código Playwright. Desde 0,36 US$/GB, sin KYC, pagar con criptomonedas.

- URL: https://pontproxy.com/es/guides/quickstart/
- Última actualización: 2026-10-05
- Publisher: PontProxy (https://pontproxy.com)

Un gateway, dos puertos y un usuario que lleva tu targeting. Copia un ejemplo de código, reemplaza USERNAME y PASSWORD, y verifica la IP de salida.

**Respuesta rápida — ¿Cómo me conecto a proxies residenciales de Reino Unido y UE?**

Para conectarte a proxies residenciales **PontProxy** de Reino Unido y UE, envía tráfico a `gw.pontproxy.com` en el puerto **7777** (HTTP/HTTPS) o **7778** (SOCKS5). Inicia sesión con el usuario y contraseña de tu área de cliente. Añade targeting al usuario, por ejemplo `-country-gb-city-london`. El tráfico residencial cuesta desde 0,36 US$/GB, se paga con criptomonedas y sin KYC — sin ID, sin selfie, sin documentos.

## Detalles de conexión

| Atributo | Valor |
| --- | --- |
| Host del gateway | `gw.pontproxy.com` |
| Puerto HTTP / HTTPS | `7777` |
| Puerto SOCKS5 | `7778` |
| Autenticación | Usuario y contraseña del área de cliente |
| Formato de usuario | `USERNAME-country-{cc}-city-{city}-session-{id}-ttl-{minutes}` |
| Rotación | Una IP nueva en cada solicitud, o sesiones fijas que controlas |
| Sesiones persistentes | Hasta 60 minutos |
| Cambio de IP 4G/5G | Una IP nueva a demanda mediante enlace o API, o automáticamente con un temporizador |
| Protocolos | HTTP, HTTPS y SOCKS5 |
| Precio | Proxy residencial desde 0,36 US$/GB · puerto dedicado 4G/5G desde $4.50/día |

## ¿Cómo configuro un proxy en Reino Unido o UE?

PontProxy, un proveedor de proxy residencial y proxies móviles 4G/5G sin KYC en Reino Unido y Europa, usa un gateway para cada plan residencial. Cinco pasos te llevan desde la compra hasta una IP de salida verificada en Reino Unido.

1. **Compra un plan** — Elige GB de proxy residencial, GB rotativos de proxies móviles 4G o un puerto dedicado 4G/5G en la página de precios. Paga con criptomonedas. Sin KYC — no se requiere ID, selfie ni documentos. El pago funciona con saldo: recargas en criptomonedas (mínimo 25 US$) y luego compras planes desde tu saldo; el saldo no usado permanece en tu cuenta.
2. **Copia tus credenciales desde el área de cliente** — Abre el área de cliente una vez que se confirme el pago. Copia tu nombre de usuario y contraseña del proxy. Un puerto dedicado 4G/5G muestra sus propios detalles de conexión y clave API allí.
3. **Construye el nombre de usuario con tu segmentación** — Agrega los parámetros de país, ciudad, sesión y ttl a tu nombre de usuario, por ejemplo USERNAME-country-gb-city-london-session-a1b2c3-ttl-30.
4. **Conecta tu herramienta** — Apunta curl, Python, Node.js, Scrapy o un navegador a gw.pontproxy.com en el puerto 7777 para HTTP/HTTPS, o al puerto 7778 para SOCKS5.
5. **Verifica la IP de salida** — Solicita https://ipinfo.io/json a través del proxy. Verifica que el país, la ciudad y el ASN coincidan con lo que solicitaste.

## ¿Cómo funciona la segmentación por nombre de usuario?

Eliges la ubicación de salida añadiendo parámetros a tu nombre de usuario. El formato es `USERNAME-country-{cc}-city-{city}-session-{id}-ttl-{minutes}`. Sustituye USERNAME por tu propio nombre de usuario y reemplaza cada valor entre llaves.

- Omite `-city-…` para usar cualquier IP en el país.
- Omite `-session-…` para obtener una IP nueva en cada solicitud.
- Añade `-session-…` con un `-ttl-…` para mantener la misma IP durante esos minutos.

### Parámetros del nombre de usuario

| Parámetro | Valor | Ejemplos | Qué hace |
| --- | --- | --- | --- |
| `country` | Código ISO 3166-1 alfa-2, en minúsculas | `gb`, `de`, `fr`, `nl`, `es`, `it`, `pl` | Define el país de salida. Reino Unido es `gb`, no `uk`. |
| `city` | Nombre de la ciudad en minúsculas, sin espacios | `london`, `manchester`, `berlin` | Define la ciudad de salida dentro del país elegido. Úsalo junto con `country`. |
| `session` | Cualquier cadena que elijas | `a1b2c3` | Mantiene la misma IP mientras la cadena sea igual. Usa solo letras y dígitos, porque los guiones separan los parámetros. |
| `ttl` | Minutos | `30` | Define cuánto tiempo se mantiene la IP sticky: Hasta 60 minutos. |

## ¿Qué host y puerto debo usar?

Usa el mismo host para ambos protocolos. Solo cambia el puerto.

| Protocolo | Host | Puerto | Úsalo para |
| --- | --- | --- | --- |
| HTTP / HTTPS | `gw.pontproxy.com` | `7777` | curl, Python requests y httpx, Node.js, Scrapy, Playwright, Puppeteer |
| SOCKS5 | `gw.pontproxy.com` | `7778` | Herramientas que necesitan SOCKS5. Usa `socks5h://` para que el proxy resuelva nombres DNS. |

Los sitios HTTPS funcionan a través del puerto HTTP. Tu cliente abre un túnel CONNECT, así TLS se ejecuta de extremo a extremo entre tú y el sitio web. Si tu contraseña contiene caracteres como `@` o `:`, codifícalos en URL dentro de las URLs del proxy.

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

curl es la forma más rápida de verificar tus credenciales. Cada comando abajo imprime la IP de salida, ciudad, país y ASN en formato JSON. En Windows, ejecuta `curl.exe` y pon el comando en una sola línea.

*curl sobre HTTP (puerto 7777)*

```bash
curl -x http://gw.pontproxy.com:7777 \
  -U "USERNAME-country-gb-city-london-session-a1b2c3-ttl-30:PASSWORD" \
  https://ipinfo.io/json
```

*curl sobre SOCKS5 (puerto 7778)*

```bash
# socks5h:// lets the proxy resolve the host name (no local DNS lookup)
curl -x "socks5h://USERNAME-country-gb-city-london-session-a1b2c3-ttl-30:PASSWORD@gw.pontproxy.com:7778" \
  https://ipinfo.io/json
```

## ¿Cómo uso el proxy en Python?

Usa `requests` para scripts simples y `httpx` para código async. Ambos leen las credenciales desde la URL del proxy. Para SOCKS5, instala `requests[socks]` o `httpx[socks]` y usa una URL `socks5h://` en el puerto 7778. httpx usa `proxy=` desde la versión 0.26, y la versión 0.28 eliminó el argumento antiguo `proxies=`.

*Python requests*

```python
# pip install requests        (SOCKS5: pip install "requests[socks]")
import requests

PROXY = (
    "http://USERNAME-country-gb-city-london-session-a1b2c3-ttl-30:PASSWORD"
    "@gw.pontproxy.com:7777"
)
proxies = {"http": PROXY, "https": PROXY}

r = requests.get("https://ipinfo.io/json", proxies=proxies, timeout=30)
r.raise_for_status()
print(r.json())

# SOCKS5 instead:
# PROXY = "socks5h://USERNAME-country-gb-city-london-session-a1b2c3-ttl-30:PASSWORD@gw.pontproxy.com:7778"
```

*Python httpx (async, tres sesiones sticky en paralelo)*

```python
# pip install httpx          (SOCKS5: pip install "httpx[socks]")
import asyncio

import httpx

GATEWAY = "gw.pontproxy.com:7777"


def proxy_url(session: str) -> str:
    user = f"USERNAME-country-gb-city-london-session-{session}-ttl-30"
    return f"http://{user}:PASSWORD@{GATEWAY}"


async def check(session: str) -> None:
    # httpx 0.26+ uses proxy= (proxies= was removed in 0.28)
    async with httpx.AsyncClient(proxy=proxy_url(session), timeout=30) as client:
        r = await client.get("https://ipinfo.io/json")
        r.raise_for_status()
        data = r.json()
        print(session, data["ip"], data.get("city"), data.get("org"))


async def main() -> None:
    # one session id = one sticky IP
    await asyncio.gather(*(check(s) for s in ("a1b2c3", "d4e5f6", "g7h8i9")))


asyncio.run(main())
```

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

Usa el `ProxyAgent` de undici y pásalo a `fetch` como el `dispatcher`. Importa `fetch` de undici también, así el agente y el cliente vienen de la misma versión del paquete. undici 8, la versión mayor actual en octubre de 2026, requiere Node.js 22.19 o superior.

*Node.js con undici ProxyAgent (guardar como check.mjs)*

```javascript
// npm install undici
import { ProxyAgent, fetch } from 'undici';

const user = 'USERNAME-country-gb-city-london-session-a1b2c3-ttl-30';
const pass = 'PASSWORD';

const proxy = new ProxyAgent({
  uri: 'http://gw.pontproxy.com:7777',
  token: `Basic ${Buffer.from(`${user}:${pass}`).toString('base64')}`,
});

const res = await fetch('https://ipinfo.io/json', { dispatcher: proxy });
console.log(await res.json());
```

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

Configura la clave `proxy` en el `meta` de cada solicitud. El HttpProxyMiddleware de Scrapy está activado por defecto (`HTTPPROXY_ENABLED = True`) y convierte las credenciales en la URL en un encabezado `Proxy-Authorization`. También puedes exportar `https_proxy` antes de iniciar el rastreo; una clave meta `proxy` tiene prioridad sobre las variables de entorno. Scrapy 2.13 añadió el método async `start()`; en versiones anteriores, usa `start_requests()`.

*Araña Scrapy (ejecutar con: scrapy runspider ipcheck.py)*

```python
# ipcheck.py
import scrapy

PROXY = (
    "http://USERNAME-country-gb-city-london-session-a1b2c3-ttl-30:PASSWORD"
    "@gw.pontproxy.com:7777"
)


class IpCheckSpider(scrapy.Spider):
    name = "ipcheck"
    custom_settings = {"HTTPPROXY_ENABLED": True}  # the default, shown for clarity

    async def start(self):  # Scrapy 2.13+; older versions: def start_requests(self)
        yield scrapy.Request("https://ipinfo.io/json", meta={"proxy": PROXY})

    def parse(self, response):
        yield response.json()
```

## ¿Cómo uso el proxy en Playwright o Puppeteer?

Usa el puerto HTTP para navegadores. Puppeteer 25 requiere Node.js 22.12 o superior. Playwright recibe el nombre de usuario y la contraseña en su opción `proxy`. Puppeteer usa la dirección del proxy como una bandera de Chrome y las credenciales mediante `page.authenticate()`.

*Playwright para Python*

```python
# pip install playwright && playwright install chromium
from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(proxy={
        "server": "http://gw.pontproxy.com:7777",
        "username": "USERNAME-country-gb-city-london-session-a1b2c3-ttl-30",
        "password": "PASSWORD",
    })
    page = browser.new_page()
    page.goto("https://ipinfo.io/json")
    print(page.inner_text("body"))
    browser.close()
```

*Puppeteer (guardar como check.mjs)*

```javascript
// npm install puppeteer
import puppeteer from 'puppeteer';

const browser = await puppeteer.launch({
  args: ['--proxy-server=http://gw.pontproxy.com:7777'],
});
const page = await browser.newPage();
await page.authenticate({
  username: 'USERNAME-country-gb-city-london-session-a1b2c3-ttl-30',
  password: 'PASSWORD',
});
await page.goto('https://ipinfo.io/json');
console.log(await page.evaluate(() => document.body.innerText));
await browser.close();
```

## ¿Cómo cambio la IP en un puerto dedicado 4G/5G?

Llama al enlace de rotación de tu puerto. Un puerto dedicado te da Una IP nueva a demanda mediante enlace o API, o automáticamente con un temporizador. En el comando a continuación, reemplaza `{port}` con el número de tu puerto y `API_KEY` con la clave mostrada para ese puerto en el área de cliente. Espera a que la llamada regrese antes de enviar nuevas solicitudes a través del puerto.

*Rotar un puerto dedicado 4G/5G*

```bash
# replace {port} with your port number and API_KEY with your key
curl "https://pontproxy.com/api/v1/mobile/{port}/rotate?key=API_KEY"
```

## ¿Cómo verifico la IP de salida y su ASN?

Abre `https://ipinfo.io/json` a través del proxy, como en los ejemplos anteriores. El JSON muestra `ip`, `city`, `region`, `country` y `org`. El campo `org` comienza con el ASN de la red, por ejemplo `AS2856` para BT. Las verificaciones a continuación no requieren token ipinfo.

- **Salida residencial:** `org` nombra un ISP consumidor. Ejemplos en Reino Unido son AS2856 (BT), AS5089 (Virgin Media), AS5607 (Sky) y AS13285 (TalkTalk).
- **Salida móvil:** `org` nombra una red móvil. Los rangos móviles de EE son anunciados por AS2856 (BT Group) y Vodafone UK móvil por AS25135. O2 UK usa AS35228 y AS29180, y Three UK usa AS206067 y AS60339.
- **IP de datacenter:** `org` nombra una empresa de hosting o cloud.

La geolocalización a nivel de ciudad es una estimación, y las bases de datos pueden diferir por una ciudad cercana. Nuestra [guía de verificación ASN](https://pontproxy.com/es/guides/check-proxy-asn/) explica el método completo, incluyendo consultas RIPEstat.

## Solución de problemas: ¿por qué no funciona mi proxy?

La mayoría de los problemas provienen de las credenciales, los puertos o un objetivo demasiado específico.

### 407 Autenticación de Proxy Requerida

La puerta de enlace no aceptó tu nombre de usuario o contraseña. HTTP define el 407 como el estado que envía un proxy cuando el cliente debe autenticarse. Copia ambos valores nuevamente desde el área de cliente. Verifica que el sufijo de destino siga el formato exacto y codifica en URL los caracteres especiales en las URLs del proxy.

### Tiempos de espera

Primero revisa el puerto: 7777 es para HTTP/HTTPS y 7778 es para SOCKS5. Confundirlos generalmente termina en un tiempo de espera o un error de protocolo. Permite TCP saliente a ambos puertos en tu firewall. Las IPs residenciales son conexiones domésticas, así que establece un tiempo de espera de 30 segundos o más y reintenta con un nuevo id de sesión.

### La ciudad es incorrecta o rara vez está disponible

Los pueblos pequeños tienen pocas IPs en línea en cualquier momento. Si ipinfo muestra una ciudad diferente o las solicitudes fallan, apunta a una ciudad cercana más grande o solo al país. Las bases de datos de geolocalización también difieren a nivel de ciudad, por lo que una ciudad vecina no siempre es un error.

### La sesión persistente terminó antes de tiempo

Una IP persistente termina cuando su ttl se agota (Hasta 60 minutos) o cuando el dispositivo residencial se desconecta. Diseña tu scraper para aceptar un cambio de IP: inicia un nuevo id de sesión y continúa.

## Preguntas de configuración

### ¿Cuáles son el host y los puertos del proxy PontProxy?

El host de la puerta de enlace es `gw.pontproxy.com`. Usa el puerto 7777 para HTTP y HTTPS, y el puerto 7778 para SOCKS5. Ambos puertos aceptan el mismo nombre de usuario y contraseña de tu área de cliente. Los sitios HTTPS funcionan a través del puerto HTTP porque tu cliente abre un túnel CONNECT y TLS funciona de extremo a extremo.

### ¿Cómo apunto a una ciudad del Reino Unido como Londres o Manchester?

Agrega el país y la ciudad a tu nombre de usuario: `USERNAME-country-gb-city-london` o `USERNAME-country-gb-city-manchester`. El código de país para Reino Unido es `gb`, el código ISO 3166-1, no `uk`. Escribe la ciudad en minúsculas y sin espacios. Consulta la página de [proxies residenciales en Reino Unido](https://pontproxy.com/es/residential-proxies/united-kingdom/) para cobertura en UK.

### ¿Cómo mantengo la misma IP para varias solicitudes?

Agrega un id de sesión y un ttl al nombre de usuario, por ejemplo `-session-a1b2c3-ttl-30`. Cada solicitud con el mismo id de sesión usa la misma IP, Hasta 60 minutos. Cambia el id de sesión para obtener una IP nueva. Sin id de sesión, obtienes una IP nueva en cada solicitud. Una sesión puede terminar antes si el dispositivo residencial se desconecta.

### ¿Cómo obtengo una IP nueva en un puerto dedicado 4G/5G?

Llama al enlace de rotación del puerto: `https://pontproxy.com/api/v1/mobile/{port}/rotate?key=API_KEY`. Reemplaza `{port}` con tu número de puerto y `API_KEY` con tu clave del área de cliente. Un puerto dedicado te da Una IP nueva a demanda mediante enlace o API, o automáticamente con un temporizador. Los puertos funcionan en EE, Vodafone, O2 y Three en UK; consulta los [proxies móviles 4G/5G](https://pontproxy.com/es/mobile-proxies/).

### ¿Debo usar HTTP o SOCKS5?

Usa HTTP en el puerto 7777 para la mayoría de trabajos: curl, Python, Node.js, Scrapy y navegadores lo soportan, y los sitios HTTPS funcionan a través de él. Usa SOCKS5 en el puerto 7778 cuando una herramienta solo soporte SOCKS5. Con SOCKS5, usa `socks5h://` para que los nombres DNS los resuelva el proxy, no tu máquina.

### ¿Necesito verificar mi identidad antes de poder conectarme?

No. **Sin KYC — no se requiere ID, selfie ni documentos. Paga con criptomonedas.** PontProxy usa Inicio de sesión con número de cuenta — correo electrónico opcional. Las credenciales aparecen en el área de cliente tan pronto como se confirma el pago. El uso de los proxies está regulado por nuestra [Política de Uso Aceptable](https://pontproxy.com/es/acceptable-use/). Los planes comienzan desde 0,36 US$/GB en la [página de precios](https://pontproxy.com/es/pricing/).

## Fuentes

1. [RFC 9110 Semántica HTTP: CONNECT (9.3.6) y 407 Proxy Authentication Required (15.5.8)](https://www.rfc-editor.org/rfc/rfc9110.html) — IETF
2. [Proxies SOCKS (socks5 vs socks5h)](https://everything.curl.dev/usingcurl/proxies/socks.html) — Everything curl
3. [Solicitudes: proxies y SOCKS](https://requests.readthedocs.io/en/latest/user/advanced/#proxies) — Requests documentation
4. [HTTPX: proxies](https://www.python-httpx.org/advanced/proxies/) — HTTPX documentation
5. [Historial de cambios de HTTPX (proxy= añadido en 0.26, proxies= eliminado en 0.28)](https://github.com/encode/httpx/blob/master/CHANGELOG.md) — Encode
6. [undici ProxyAgent](https://github.com/nodejs/undici/blob/main/docs/docs/api/ProxyAgent.md) — Node.js undici
7. [Scrapy HttpProxyMiddleware](https://docs.scrapy.org/en/latest/topics/downloader-middleware.html) — Scrapy documentation
8. [Arañas Scrapy: start() (añadido en 2.13)](https://docs.scrapy.org/en/latest/topics/spiders.html) — Scrapy documentation
9. [Playwright para Python: proxy HTTP](https://playwright.dev/python/docs/network#http-proxy) — Playwright
10. [Page.authenticate()](https://pptr.dev/api/puppeteer.page.authenticate) — Puppeteer
11. [undici en npm (v8, motores: Node.js >= 22.19.0)](https://www.npmjs.com/package/undici) — npm (2026-10-05)
12. [puppeteer en npm (v25, motores: Node.js >= 22.12.0)](https://www.npmjs.com/package/puppeteer) — npm (2026-10-05)
13. [ISO 3166-1 alfa-2 (GB, y UK como código reservado excepcionalmente)](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) — Wikipedia
14. [Documentación para desarrolladores de IPinfo](https://ipinfo.io/developers) — IPinfo
15. [API de datos RIPEstat (network-info)](https://stat.ripe.net/docs/data_api) — RIPE NCC
16. [Resumen de prefijos RIPEstat: rango móvil EE 31.94.0.0/16 originado por AS2856](https://stat.ripe.net/data/prefix-overview/data.json?resource=31.94.0.0/16) — RIPE NCC (2026-10-05)
17. [Resumen de prefijos RIPEstat: rango O2 UK 82.132.128.0/22 originado por AS29180](https://stat.ripe.net/data/prefix-overview/data.json?resource=82.132.128.0/22) — RIPE NCC (2026-10-05)

**¿Listo para conectarte?** Compra un proxy residencial GB o un puerto 4G/5G con criptomonedas y recibe las credenciales tan pronto como se confirme el pago. Sin KYC. [Consigue proxies residenciales — desde 0,36 US$/GB](https://pontproxy.com/es/pricing/) · [Pagar con criptomonedas](https://pontproxy.com/es/crypto-proxies/)

---

PontProxy: PontProxy es un proveedor de proxies de Reino Unido y Europa: IPs residenciales con segmentación por país, ciudad e ISP, además de puertos dedicados 4G/5G de EE, Vodafone, O2 y Three, pagados con criptomonedas y sin KYC — sin identificación, sin selfie, sin documentos. Residencial desde 0,36 US$/GB.