# Quickstart: connect to UK & EU proxies in five steps

> Connect to PontProxy UK & EU proxies: gateway, ports, username targeting, curl, Python, Node.js and Playwright code. From $0.36/GB, no KYC, crypto.

- URL: https://pontproxy.com/guides/quickstart/
- Last updated: 2026-10-05
- Publisher: PontProxy (https://pontproxy.com)

One gateway, two ports and a username that carries your targeting. Copy a code sample, replace USERNAME and PASSWORD, and check the exit IP.

**Quick answer — How do I connect to UK & EU proxies?**

To connect to **PontProxy** UK & EU proxies, send traffic to `gw.pontproxy.com` on port **7777** (HTTP/HTTPS) or **7778** (SOCKS5). Log in with the username and password from your client area. Add targeting to the username, for example `-country-gb-city-london`. Residential traffic costs from $0.36/GB, paid in crypto with no KYC — no ID, no selfie, no documents.

## Connection details

| Attribute | Value |
| --- | --- |
| Gateway host | `gw.pontproxy.com` |
| HTTP / HTTPS port | `7777` |
| SOCKS5 port | `7778` |
| Authentication | Username and password from the client area |
| Username format | `USERNAME-country-{cc}-city-{city}-session-{id}-ttl-{minutes}` |
| Rotation | a new IP on every request, or sticky sessions you control |
| Sticky sessions | up to 60 minutes |
| 4G/5G IP change | a new IP on demand by link or API, or automatically on a timer |
| Protocols | HTTP, HTTPS and SOCKS5 |
| Price | Residential from $0.36/GB · dedicated 4G/5G port from $4.50/day |

## How do I set up a UK or EU proxy?

PontProxy, a no-KYC UK & Europe residential and 4G/5G proxy provider, uses one gateway for every residential plan. Five steps take you from purchase to a verified UK exit IP.

1. **Buy a plan** — Choose residential GB, rotating mobile GB or a dedicated 4G/5G port on the pricing page. Pay in crypto. No KYC — no ID, no selfie, no documents. Payment works by balance: you top up in crypto (minimum $25), then buy plans from your balance; unused balance stays on your account.
2. **Copy your credentials from the client area** — Open the client area once the payment confirms. Copy your proxy username and password. A dedicated 4G/5G port lists its own connection details and API key there.
3. **Build the username with your targeting** — Add the country, city, session and ttl parameters to your username, for example USERNAME-country-gb-city-london-session-a1b2c3-ttl-30.
4. **Connect your tool** — Point curl, Python, Node.js, Scrapy or a browser at gw.pontproxy.com on port 7777 for HTTP/HTTPS, or port 7778 for SOCKS5.
5. **Verify the exit IP** — Request https://ipinfo.io/json through the proxy. Check that the country, the city and the ASN match what you asked for.

## How does the username targeting work?

You choose the exit location by adding parameters to your username. The format is `USERNAME-country-{cc}-city-{city}-session-{id}-ttl-{minutes}`. Replace USERNAME with your own username, and replace each value in braces.

- Leave out `-city-…` to use any IP in the country.
- Leave out `-session-…` to get a new IP on every request.
- Add `-session-…` with a `-ttl-…` to keep the same IP for that many minutes.

### Username parameters

| Parameter | Value | Examples | What it does |
| --- | --- | --- | --- |
| `country` | ISO 3166-1 alpha-2 code, lower case | `gb`, `de`, `fr`, `nl`, `es`, `it`, `pl` | Sets the exit country. The United Kingdom is `gb`, not `uk`. |
| `city` | City name in lower case, without spaces | `london`, `manchester`, `berlin` | Sets the exit city inside the chosen country. Use it together with `country`. |
| `session` | Any string you choose | `a1b2c3` | Keeps the same IP while the string stays the same. Use letters and digits only, because hyphens separate the parameters. |
| `ttl` | Minutes | `30` | Sets how long the sticky IP is kept: up to 60 minutes. |

## Which host and port do I use?

Use the same host for both protocols. Only the port changes.

| Protocol | Host | Port | Use it for |
| --- | --- | --- | --- |
| HTTP / HTTPS | `gw.pontproxy.com` | `7777` | curl, Python requests and httpx, Node.js, Scrapy, Playwright, Puppeteer |
| SOCKS5 | `gw.pontproxy.com` | `7778` | Tools that need SOCKS5. Use `socks5h://` so the proxy resolves DNS names. |

HTTPS sites work through the HTTP port. Your client opens a CONNECT tunnel, so TLS runs end to end between you and the website. If your password contains characters such as `@` or `:`, URL-encode them inside proxy URLs.

## How do I test the proxy with curl?

curl is the fastest way to check your credentials. Each command below prints the exit IP, city, country and ASN as JSON. On Windows, run `curl.exe` and put the command on one line.

*curl over HTTP (port 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 over SOCKS5 (port 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
```

## How do I use the proxy in Python?

Use `requests` for simple scripts and `httpx` for async code. Both read the credentials from the proxy URL. For SOCKS5, install `requests[socks]` or `httpx[socks]` and use a `socks5h://` URL on port 7778. httpx has used `proxy=` since version 0.26, and version 0.28 removed the old `proxies=` argument.

*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, three sticky sessions in parallel)*

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

## How do I use the proxy in Node.js?

Use the `ProxyAgent` from undici and pass it to `fetch` as the `dispatcher`. Import `fetch` from undici as well, so the agent and the client come from the same package version. undici 8, the current major version in October 2026, needs Node.js 22.19 or later.

*Node.js with undici ProxyAgent (save as 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());
```

## How do I use the proxy with Scrapy?

Set the `proxy` key in each request's `meta`. Scrapy's HttpProxyMiddleware is on by default (`HTTPPROXY_ENABLED = True`) and turns the credentials in the URL into a `Proxy-Authorization` header. You can also export `https_proxy` before you run the crawl; a `proxy` meta key takes precedence over the environment variables. Scrapy 2.13 added the async `start()` method; on older versions, use `start_requests()`.

*Scrapy spider (run with: 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()
```

## How do I use the proxy in Playwright or Puppeteer?

Use the HTTP port for browsers. Puppeteer 25 needs Node.js 22.12 or later. Playwright takes the username and password in its `proxy` option. Puppeteer takes the proxy address as a Chrome flag and the credentials through `page.authenticate()`.

*Playwright for 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 (save as 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();
```

## How do I change the IP on a dedicated 4G/5G port?

Call the rotation link of your port. A dedicated port gives you a new IP on demand by link or API, or automatically on a timer. In the command below, replace `{port}` with your port number and `API_KEY` with the key shown for that port in the client area. Wait until the call returns before you send new requests through the port.

*Rotate a dedicated 4G/5G port*

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

## How do I check the exit IP and its ASN?

Open `https://ipinfo.io/json` through the proxy, as in the samples above. The JSON shows `ip`, `city`, `region`, `country` and `org`. The `org` field starts with the network's ASN, for example `AS2856` for BT. The checks below need no ipinfo token.

- **Residential exit:** `org` names a consumer ISP. UK examples are AS2856 (BT), AS5089 (Virgin Media), AS5607 (Sky) and AS13285 (TalkTalk).
- **Mobile exit:** `org` names a mobile network. EE mobile ranges are announced by AS2856 (BT Group) and Vodafone UK mobile by AS25135. O2 UK uses AS35228 and AS29180, and Three UK uses AS206067 and AS60339.
- **Datacenter IP:** `org` names a hosting or cloud company.

City-level geolocation is an estimate, and databases can disagree by a nearby town. Our [ASN check guide](https://pontproxy.com/guides/check-proxy-asn/) explains the full method, including RIPEstat lookups.

## Troubleshooting: why is my proxy not working?

Most problems come from credentials, ports or targeting that is too narrow.

### 407 Proxy Authentication Required

The gateway did not accept your username or password. HTTP defines 407 as the status a proxy sends when the client must authenticate. Copy both values again from the client area. Check that the targeting suffix follows the format exactly, and URL-encode special characters in proxy URLs.

### Timeouts

Check the port first: 7777 is for HTTP/HTTPS and 7778 is for SOCKS5. Mixing them up usually ends in a timeout or a protocol error. Allow outbound TCP to both ports on your firewall. Residential IPs are home connections, so set a timeout of 30 seconds or more and retry with a new session id.

### The city is wrong or rarely available

Small towns have few IPs online at any moment. If ipinfo shows a different city, or requests fail, target a larger nearby city or the country only. Geolocation databases also disagree at city level, so a neighbouring town is not always an error.

### The sticky session ended early

A sticky IP ends when its ttl runs out (up to 60 minutes) or when the residential device goes offline. Build your scraper to accept an IP change: start a new session id and continue.

## Setup questions

### What are the PontProxy proxy host and ports?

The gateway host is `gw.pontproxy.com`. Use port 7777 for HTTP and HTTPS, and port 7778 for SOCKS5. Both ports accept the same username and password from your client area. HTTPS websites work through the HTTP port, because your client opens a CONNECT tunnel and TLS runs end to end.

### How do I target a UK city such as London or Manchester?

Add the country and city to your username: `USERNAME-country-gb-city-london` or `USERNAME-country-gb-city-manchester`. The country code for the United Kingdom is `gb`, the ISO 3166-1 code, not `uk`. Write the city in lower case without spaces. See the [UK residential proxies](https://pontproxy.com/residential-proxies/united-kingdom/) page for UK coverage.

### How do I keep the same IP for several requests?

Add a session id and a ttl to the username, for example `-session-a1b2c3-ttl-30`. Every request with the same session id uses the same IP, up to 60 minutes. Change the session id to get a new IP. Without a session id, you get a new IP on every request. A session can end early if the residential device goes offline.

### How do I get a new IP on a dedicated 4G/5G port?

Call the rotation link of the port: `https://pontproxy.com/api/v1/mobile/{port}/rotate?key=API_KEY`. Replace `{port}` with your port number and `API_KEY` with your key from the client area. A dedicated port gives you a new IP on demand by link or API, or automatically on a timer. Ports run on EE, Vodafone, O2 and Three in the UK; see [4G/5G mobile proxies](https://pontproxy.com/mobile-proxies/).

### Should I use HTTP or SOCKS5?

Use HTTP on port 7777 for most work: curl, Python, Node.js, Scrapy and browsers all support it, and HTTPS sites work through it. Use SOCKS5 on port 7778 when a tool only supports SOCKS5. With SOCKS5, use `socks5h://` so DNS names are resolved by the proxy, not on your machine.

### Do I need to verify my identity before I can connect?

No. **No KYC — no ID, no selfie, no documents. Pay in crypto.** PontProxy uses account-number login — email optional. Credentials appear in the client area as soon as the payment confirms. Use of the proxies is governed by our [Acceptable Use Policy](https://pontproxy.com/acceptable-use/). Plans start from $0.36/GB on the [pricing page](https://pontproxy.com/pricing/).

## Sources

1. [RFC 9110 HTTP Semantics: CONNECT (9.3.6) and 407 Proxy Authentication Required (15.5.8)](https://www.rfc-editor.org/rfc/rfc9110.html) — IETF
2. [SOCKS proxies (socks5 vs socks5h)](https://everything.curl.dev/usingcurl/proxies/socks.html) — Everything curl
3. [Requests: proxies and 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. [HTTPX changelog (proxy= added in 0.26, proxies= removed 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. [Scrapy spiders: start() (added in 2.13)](https://docs.scrapy.org/en/latest/topics/spiders.html) — Scrapy documentation
9. [Playwright for Python: HTTP proxy](https://playwright.dev/python/docs/network#http-proxy) — Playwright
10. [Page.authenticate()](https://pptr.dev/api/puppeteer.page.authenticate) — Puppeteer
11. [undici on npm (v8, engines: Node.js >= 22.19.0)](https://www.npmjs.com/package/undici) — npm (2026-10-05)
12. [puppeteer on npm (v25, engines: Node.js >= 22.12.0)](https://www.npmjs.com/package/puppeteer) — npm (2026-10-05)
13. [ISO 3166-1 alpha-2 (GB, and UK as an exceptionally reserved code)](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) — Wikipedia
14. [IPinfo developer documentation](https://ipinfo.io/developers) — IPinfo
15. [RIPEstat Data API (network-info)](https://stat.ripe.net/docs/data_api) — RIPE NCC
16. [RIPEstat prefix overview: EE mobile range 31.94.0.0/16 originated by AS2856](https://stat.ripe.net/data/prefix-overview/data.json?resource=31.94.0.0/16) — RIPE NCC (2026-10-05)
17. [RIPEstat prefix overview: O2 UK range 82.132.128.0/22 originated by AS29180](https://stat.ripe.net/data/prefix-overview/data.json?resource=82.132.128.0/22) — RIPE NCC (2026-10-05)

**Ready to connect?** Buy residential GB or a 4G/5G port with crypto and get credentials as soon as the payment confirms. No KYC. [Get residential proxies — from $0.36/GB](https://pontproxy.com/pricing/) · [Pay with crypto](https://pontproxy.com/crypto-proxies/)

---

PontProxy: PontProxy is a UK & Europe proxy provider: residential IPs with country, city and ISP targeting, plus dedicated EE, Vodafone, O2 and Three 4G/5G ports, paid in crypto with no KYC — no ID, no selfie, no documents. Residential from $0.36/GB.