# Guida rapida: connettersi ai proxy UK & UE in cinque passaggi

> Connettiti ai proxy residenziali UK & UE di PontProxy: gateway, porte, targeting username, curl, Python, Node.js e codice Playwright. Da 0,36 USD/GB, senza KYC, crypto.

- URL: https://pontproxy.com/it/guides/quickstart/
- Ultimo aggiornamento: 2026-10-05
- Publisher: PontProxy (https://pontproxy.com)

Un gateway, due porte e un username che include il tuo targeting. Copia un esempio di codice, sostituisci USERNAME e PASSWORD, e verifica l'IP di uscita.

**Risposta rapida — Come mi connetto ai proxy UK & UE?**

Per connetterti ai proxy residenziali **PontProxy** UK & UE, invia traffico a `gw.pontproxy.com` sulla porta **7777** (HTTP/HTTPS) o **7778** (SOCKS5). Accedi con username e password dal tuo client area. Aggiungi il targeting allo username, per esempio `-country-gb-city-london`. Il traffico residenziale parte da 0,36 USD/GB, pagato in crypto senza KYC — niente ID, niente selfie, niente documenti.

## Dettagli di connessione

| Attributo | Valore |
| --- | --- |
| Host gateway | `gw.pontproxy.com` |
| Porta HTTP / HTTPS | `7777` |
| Porta SOCKS5 | `7778` |
| Autenticazione | Username e password dal client area |
| Formato username | `USERNAME-country-{cc}-city-{city}-session-{id}-ttl-{minutes}` |
| Rotazione | un nuovo IP a ogni richiesta, oppure sessioni sticky che controlli tu |
| Sessioni sticky | fino a 60 minuti |
| Cambio IP 4G/5G | un nuovo IP su richiesta tramite link o API, o automaticamente con un timer |
| Protocolli | HTTP, HTTPS e SOCKS5 |
| Prezzo | Proxy residenziali da 0,36 USD/GB · porta dedicata 4G/5G da $4,50/giorno |

## Come configuro un proxy UK o UE?

PontProxy, provider di proxy residenziali e proxy mobili 4G/5G senza KYC per UK & Europa, usa un gateway unico per ogni piano residenziale. Cinque passaggi ti portano dall'acquisto a un IP di uscita UK verificato.

1. **Acquista un piano** — Scegli proxy residenziali GB, proxy mobili 4G rotanti o una porta dedicata 4G/5G nella pagina prezzi. Paga in crypto. Senza KYC — niente ID, selfie o documenti. Il pagamento funziona con saldo: ricarichi in crypto (minimo 25 USD), poi acquisti piani dal saldo; il saldo non usato resta sul tuo account.
2. **Copia le tue credenziali dal client area** — Apri il client area una volta confermato il pagamento. Copia username e password proxy. Una porta dedicata 4G/5G mostra i propri dettagli di connessione e chiave API.
3. **Costruisci lo username con il tuo targeting** — Aggiungi i parametri paese, città, sessione e ttl al tuo username, per esempio USERNAME-country-gb-city-london-session-a1b2c3-ttl-30.
4. **Connetti il tuo strumento** — Collega curl, Python, Node.js, Scrapy o un browser a gw.pontproxy.com sulla porta 7777 per HTTP/HTTPS, o sulla porta 7778 per SOCKS5.
5. **Verifica l’IP di uscita** — Richiedi https://ipinfo.io/json tramite il proxy. Verifica che paese, città e ASN corrispondano a quanto richiesto.

## Come funziona il targeting tramite username?

Scegli la posizione di uscita aggiungendo parametri al tuo username. Il formato è `USERNAME-country-{cc}-city-{city}-session-{id}-ttl-{minutes}`. Sostituisci USERNAME con il tuo username e sostituisci ogni valore tra parentesi.

- Ometti `-city-…` per usare qualsiasi IP nel paese.
- Ometti `-session-…` per ottenere un nuovo IP a ogni richiesta.
- Aggiungi `-session-…` con un `-ttl-…` per mantenere lo stesso IP per tanti minuti.

### Parametri dello username

| Parametro | Valore | Esempi | Cosa fa |
| --- | --- | --- | --- |
| `country` | Codice ISO 3166-1 alpha-2, minuscolo | `gb`, `de`, `fr`, `nl`, `es`, `it`, `pl` | Imposta il paese di uscita. Il Regno Unito è `gb`, non `uk`. |
| `city` | Nome della città in minuscolo, senza spazi | `london`, `manchester`, `berlin` | Imposta la città di uscita all'interno del paese scelto. Usalo insieme a `country`. |
| `session` | Qualsiasi stringa a scelta | `a1b2c3` | Mantiene lo stesso IP finché la stringa resta uguale. Usa solo lettere e numeri, perché i trattini separano i parametri. |
| `ttl` | Minuti | `30` | Imposta per quanto tempo mantenere l'IP sticky: fino a 60 minuti. |

## Quale host e porta devo usare?

Usa lo stesso host per entrambi i protocolli. Cambia solo la porta.

| Protocollo | Host | Porta | Usalo per |
| --- | --- | --- | --- |
| HTTP / HTTPS | `gw.pontproxy.com` | `7777` | curl, Python requests e httpx, Node.js, Scrapy, Playwright, Puppeteer |
| SOCKS5 | `gw.pontproxy.com` | `7778` | Strumenti che richiedono SOCKS5. Usa `socks5h://` così il proxy risolve i nomi DNS. |

I siti HTTPS funzionano tramite la porta HTTP. Il tuo client apre un tunnel CONNECT, quindi TLS funziona end-to-end tra te e il sito web. Se la tua password contiene caratteri come `@` o `:`, codificali in URL all’interno degli URL del proxy.

## Come testo il proxy con curl?

curl è il modo più veloce per verificare le tue credenziali. Ogni comando qui sotto stampa l’IP di uscita, città, paese e ASN in formato JSON. Su Windows, esegui `curl.exe` e metti il comando su una sola riga.

*curl su HTTP (porta 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 su SOCKS5 (porta 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
```

## Come uso il proxy in Python?

Usa `requests` per script semplici e `httpx` per codice async. Entrambi leggono le credenziali dall’URL del proxy. Per SOCKS5, installa `requests[socks]` o `httpx[socks]` e usa un URL `socks5h://` sulla porta 7778. httpx usa `proxy=` dalla versione 0.26, e la versione 0.28 ha rimosso il vecchio argomento `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, tre sessioni sticky in parallelo)*

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

## Come uso il proxy in Node.js?

Usa `ProxyAgent` da undici e passalo a `fetch` come `dispatcher`. Importa anche `fetch` da undici, così agent e client vengono dalla stessa versione del pacchetto. undici 8, la versione principale attuale a ottobre 2026, richiede Node.js 22.19 o superiore.

*Node.js con undici ProxyAgent (salva come 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());
```

## Come uso il proxy con Scrapy?

Imposta la chiave `proxy` in `meta` di ogni richiesta. HttpProxyMiddleware di Scrapy è attivo di default (`HTTPPROXY_ENABLED = True`) e trasforma le credenziali nell’URL in un header `Proxy-Authorization`. Puoi anche esportare `https_proxy` prima di avviare il crawl; una chiave meta `proxy` ha priorità sulle variabili d’ambiente. Scrapy 2.13 ha aggiunto il metodo async `start()`; nelle versioni più vecchie usa `start_requests()`.

*Scrapy spider (esegui 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()
```

## Come uso il proxy in Playwright o Puppeteer?

Usa la porta HTTP per i browser. Puppeteer 25 richiede Node.js 22.12 o versioni successive. Playwright accetta nome utente e password nella sua opzione `proxy`. Puppeteer prende l'indirizzo proxy come flag di Chrome e le credenziali tramite `page.authenticate()`.

*Playwright per 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 (salva come 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();
```

## Come cambio l'IP su una porta dedicata 4G/5G?

Chiama il link di rotazione della tua porta. Una porta dedicata ti dà un nuovo IP su richiesta tramite link o API, o automaticamente con un timer. Nel comando qui sotto, sostituisci `{port}` con il numero della tua porta e `API_KEY` con la chiave mostrata per quella porta nell'area clienti. Attendi che la chiamata ritorni prima di inviare nuove richieste attraverso la porta.

*Ruota una porta dedicata 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"
```

## Come verifico l'IP di uscita e il suo ASN?

Apri `https://ipinfo.io/json` tramite il proxy, come negli esempi sopra. Il JSON mostra `ip`, `city`, `region`, `country` e `org`. Il campo `org` inizia con l'ASN della rete, per esempio `AS2856` per BT. I controlli qui sotto non richiedono token ipinfo.

- **Uscita residenziale:** `org` indica un ISP consumer. Esempi UK sono AS2856 (BT), AS5089 (Virgin Media), AS5607 (Sky) e AS13285 (TalkTalk).
- **Uscita mobile:** `org` indica una rete mobile. Gli intervalli mobili EE sono annunciati da AS2856 (BT Group) e Vodafone UK mobile da AS25135. O2 UK usa AS35228 e AS29180, e Three UK usa AS206067 e AS60339.
- **IP datacenter:** `org` indica una società di hosting o cloud.

La geolocalizzazione a livello di città è una stima, e i database possono differire per una città vicina. La nostra [guida al controllo ASN](https://pontproxy.com/it/guides/check-proxy-asn/) spiega il metodo completo, inclusi i lookup RIPEstat.

## Risoluzione problemi: perché il mio proxy non funziona?

La maggior parte dei problemi deriva da credenziali, porte o targeting troppo restrittivo.

### 407 Proxy Authentication Required

Il gateway non ha accettato il tuo nome utente o password. HTTP definisce 407 come lo stato che un proxy invia quando il client deve autenticarsi. Copia di nuovo entrambi i valori dall'area clienti. Controlla che il suffisso di targeting segua esattamente il formato e codifica in URL i caratteri speciali negli URL del proxy.

### Timeout

Controlla prima la porta: 7777 è per HTTP/HTTPS e 7778 è per SOCKS5. Scambiarle di solito causa timeout o errore di protocollo. Consenti il traffico TCP in uscita su entrambe le porte nel firewall. Gli IP residenziali sono connessioni domestiche, quindi imposta un timeout di 30 secondi o più e riprova con un nuovo session id.

### La città è sbagliata o raramente disponibile

I piccoli paesi hanno poche IP online in ogni momento. Se ipinfo mostra una città diversa o le richieste falliscono, punta a una città più grande vicina o solo al paese. Anche i database di geolocalizzazione possono differire a livello di città, quindi una città vicina non è sempre un errore.

### La sessione sticky è terminata prima

Un IP sticky termina quando il suo ttl scade (fino a 60 minuti) o quando il dispositivo residenziale va offline. Progetta il tuo scraper per accettare un cambio IP: avvia un nuovo session id e continua.

## Domande di configurazione

### Quali sono host e porte proxy PontProxy?

L'host gateway è `gw.pontproxy.com`. Usa la porta 7777 per HTTP e HTTPS, e la porta 7778 per SOCKS5. Entrambe le porte accettano lo stesso nome utente e password dall'area clienti. I siti HTTPS funzionano tramite la porta HTTP, perché il client apre un tunnel CONNECT e TLS funziona end to end.

### Come targettizzo una città UK come Londra o Manchester?

Aggiungi paese e città al nome utente: `USERNAME-country-gb-city-london` o `USERNAME-country-gb-city-manchester`. Il codice paese per il Regno Unito è `gb`, il codice ISO 3166-1, non `uk`. Scrivi la città in minuscolo senza spazi. Vedi la pagina [proxy residenziali UK](https://pontproxy.com/it/residential-proxies/united-kingdom/) per la copertura UK.

### Come mantengo lo stesso IP per più richieste?

Aggiungi un session id e un ttl al nome utente, per esempio `-session-a1b2c3-ttl-30`. Ogni richiesta con lo stesso session id usa lo stesso IP, fino a 60 minuti. Cambia il session id per ottenere un nuovo IP. Senza session id, ottieni un nuovo IP a ogni richiesta. Una sessione può terminare prima se il dispositivo residenziale va offline.

### Come ottengo un nuovo IP su una porta dedicata 4G/5G?

Chiama il link di rotazione della porta: `https://pontproxy.com/api/v1/mobile/{port}/rotate?key=API_KEY`. Sostituisci `{port}` con il numero della tua porta e `API_KEY` con la tua chiave dall'area clienti. Una porta dedicata ti dà un nuovo IP su richiesta tramite link o API, o automaticamente con un timer. Le porte funzionano su EE, Vodafone, O2 e Three nel Regno Unito; vedi [proxy mobili 4G/5G](https://pontproxy.com/it/mobile-proxies/).

### Devo usare HTTP o SOCKS5?

Usa HTTP sulla porta 7777 per la maggior parte del lavoro: curl, Python, Node.js, Scrapy e browser lo supportano tutti, e i siti HTTPS funzionano tramite questa porta. Usa SOCKS5 sulla porta 7778 quando uno strumento supporta solo SOCKS5. Con SOCKS5, usa `socks5h://` così i nomi DNS sono risolti dal proxy, non dalla tua macchina.

### Devo verificare la mia identità prima di connettermi?

No. **Nessun KYC — niente ID, niente selfie, niente documenti. Paga in crypto.** PontProxy usa login con numero account — email facoltativa. Le credenziali appaiono nell'area clienti appena il pagamento è confermato. L'uso dei proxy è regolato dalla nostra [Acceptable Use Policy](https://pontproxy.com/it/acceptable-use/). I piani partono da 0,36 USD/GB nella [pagina prezzi](https://pontproxy.com/it/pricing/).

## Fonti

1. [RFC 9110 HTTP Semantics: CONNECT (9.3.6) e 407 Proxy Authentication Required (15.5.8)](https://www.rfc-editor.org/rfc/rfc9110.html) — IETF
2. [Proxy SOCKS (socks5 vs socks5h)](https://everything.curl.dev/usingcurl/proxies/socks.html) — Everything curl
3. [Richieste: proxy e SOCKS](https://requests.readthedocs.io/en/latest/user/advanced/#proxies) — Requests documentation
4. [HTTPX: proxy](https://www.python-httpx.org/advanced/proxies/) — HTTPX documentation
5. [Registro modifiche HTTPX (proxy= aggiunto in 0.26, proxies= rimosso in 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. [Ragni Scrapy: start() (aggiunto in 2.13)](https://docs.scrapy.org/en/latest/topics/spiders.html) — Scrapy documentation
9. [Playwright per 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 su npm (v8, motori: Node.js >= 22.19.0)](https://www.npmjs.com/package/undici) — npm (2026-10-05)
12. [puppeteer su npm (v25, motori: Node.js >= 22.12.0)](https://www.npmjs.com/package/puppeteer) — npm (2026-10-05)
13. [ISO 3166-1 alpha-2 (GB, e UK come codice eccezionalmente riservato)](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) — Wikipedia
14. [Documentazione per sviluppatori IPinfo](https://ipinfo.io/developers) — IPinfo
15. [RIPEstat Data API (network-info)](https://stat.ripe.net/docs/data_api) — RIPE NCC
16. [Panoramica prefisso RIPEstat: intervallo mobile EE 31.94.0.0/16 originato da AS2856](https://stat.ripe.net/data/prefix-overview/data.json?resource=31.94.0.0/16) — RIPE NCC (2026-10-05)
17. [Panoramica prefisso RIPEstat: intervallo O2 UK 82.132.128.0/22 originato da AS29180](https://stat.ripe.net/data/prefix-overview/data.json?resource=82.132.128.0/22) — RIPE NCC (2026-10-05)

**Pronto a connetterti?** Acquista proxy residenziali GB o una porta 4G/5G con crypto e ricevi le credenziali non appena il pagamento è confermato. Senza KYC. [Ottieni proxy residenziali — da 0,36 USD/GB](https://pontproxy.com/it/pricing/) · [Paga con crypto](https://pontproxy.com/it/crypto-proxies/)

---

PontProxy: PontProxy è un provider di proxy per UK ed Europa: IP residenziali con targeting per paese, città e ISP, più porte dedicate EE, Vodafone, O2 e Three 4G/5G, pagate in crypto senza KYC — nessun documento d'identità, nessun selfie, nessun altro documento. Residenziali a partire da 0,36 USD/GB.