# Proxy Connected, Browser Still Direct: WebRTC Left the Cloud Path Open

*Original FreePolicyTools research · 17 November 2026 · Gap-deepened 18 November 2026*

A browser can send its page fetches through a residential proxy while WebRTC
STUN still advertises a different public address. On a Cursor-hosted USA cloud
VM, we configured Playwright Chromium with ProxySeller residential HTTP and
SOCKS paths and compared those runs with the same machine’s cloud-direct
egress.

Across **seven controlled visits** (cloud-direct twice, HTTP proxy twice, SOCKS
proxy twice, and one dead-proxy check), document IP echoes followed the proxy
when it was engaged, while server-reflexive WebRTC candidates **never matched
the proxy document echo**. In multiple proxy runs, the STUN-reflexive address
instead matched the cloud-direct address set. When the HTTP proxy port was
intentionally dead, all four document echoes failed with
`ECONNREFUSED 127.0.0.1:9`, but WebRTC still produced a reflexive candidate on
the cloud path. Every visit ended ICE gathering in `timeout` while still
returning host + srflx candidates. No IPv6 addresses appeared on document or
WebRTC surfaces in this package (`api64` returned IPv4).

These are browser-path findings on one VM, one Chromium build, and one
residential package. They are not proof of provider logging, deception, or a
product-wide defect. CometVPN was not measured as a tunnel on this host;
affiliate mentions are product context only.

Public package:
[research-article.md](/research/browser-path-leak-study/research-article.md) ·
[protocol.md](/research/browser-path-leak-study/protocol.md) ·
[summary-table.json](/research/browser-path-leak-study/summary-table.json) ·
[sha-relations.json](/research/browser-path-leak-study/sha-relations.json) ·
[REPRODUCE.md](/research/browser-path-leak-study/REPRODUCE.md)

For background, read our [HTTP versus SOCKS proxy guide](/blog/http-vs-socks-proxies/),
[WebRTC and IPv6 leak guide](/blog/ip-leaks-webrtc-and-ipv6/),
[VPN versus proxy comparison](/blog/vpn-vs-proxy/), and the earlier
[proxy routing research](/blog/proxy-routing-research/) on application
environment variables (a different layer from this browser study).

## Why this study exists

Earlier FreePolicyTools work measured VPN-website warning pages, tracker
payloads inside a working Proton CLI tunnel, HTTP-client environment-variable
routing, and paid-proxy CONNECT authentication boundaries. Those studies answer
whether an *application* honors a proxy setting, or whether a *VPN product page*
warns about protection gaps.

This study asks a different operational question that privacy tooling users
actually meet:

**If Chromium is told to use a residential proxy, do the surfaces a website can
see—document fetches and WebRTC ICE—agree on one public identity, or does any
observed path still match the machine’s direct egress?**

The cloud amendment freezes that question onto Cursor-hosted USA VMs. Kenya ISP
wireless, Proton Desktop/CLI, NetworkManager WireGuard profiles, and stacked
VPN-plus-proxy conditions from the October draft are out of scope here. CometVPN
is VPN-only: it must not be used as HTTP/SOCKS, and we do not claim tunnel
results without a proven VPN path on the host.

## Collection chronology (what ran, in order)

| UTC window | Event | Evidence |
|---|---|---|
| ~17:22 | Runtime Secret **names** present for all five `PROXYSELLER_*` keys (values never logged) | `secret-presence-probe.json`, `secret-presence-probe-node.json` |
| ~14:59 | Cloud-direct baselines p1/p2 (full fixture: page fetches + WebRTC) | `cloud-direct-p1.json`, `cloud-direct-p2.json` |
| Pre-A1 collection | Loopback-bypass mistake: fixture forced through residential gateway → `503 Target host denied`, 90s timeout | `http-fixture-debug.json` |
| Pre-A1 collection | Playwright HTTP smoke through residential path succeeded (`sha12` `d916dfcb511f`) | `playwright-http-smoke.json` |
| Pre-A1 collection | Independent urllib HTTP CONNECT probe OK; Requests/SOCKS probe modules missing on host | `proxy-connectivity-probe.json` |
| ~17:40 | Env discovery: 50 keys; five `PROXYSELLER_*` names; HTTP+SOCKS ports both length 5 and equal (`10000`) | `env-discovery.json` |
| Native SOCKS attempt | `Browser does not support socks5 proxy authentication` | `chromium-socks-auth-guard.json` |
| 17:48:26–17:49:43 | A1 matrix: HTTP p1 → SOCKS p1 → HTTP p2 → SOCKS p2 → dead p1 | per-visit JSON + screenshots |

Pass 2 reverses HTTP/SOCKS order relative to pass 1, matching the frozen
protocol. `run-status.json` records `mode: full-a1`, completed mains
`cloud-direct` / `proxy-us-http` / `proxy-us-socks`, supplementary
`proxy-dead`, and the SOCKS anonymizer note.

## What we measured

### Platform and browser

| Dimension | Recorded value |
|---|---|
| Host | Cursor Cloud Agent VM |
| Cloud-direct org/country (ipinfo) | `AS14618 Amazon.com, Inc.` / US |
| Browser | Playwright Chromium **131.0.6778.33** |
| Locale / timezone / viewport | `en-US` / `UTC` / 1360×900 |
| Profile | Fresh isolated context per visit; no personal profile |
| Collection window | 17 November 2026 UTC (≤7-day protocol window) |
| ICE gather timeout | 8 seconds (collector); all seven visits ended `iceState: timeout` with host+srflx still present |
| Document echo source (proxy/dead) | Playwright `APIRequestContext` bound to the same context proxy |
| Document echo source (cloud-direct) | In-page fixture fetches |
| WebRTC under proxy/dead | Local `webrtc-only.html` fixture (loopback bypass) |
| Independent route checks | Python `urllib` echoes + `ip route` before/after each visit |

### Surfaces

1. **Document IP echoes** (HTTPS):
   - `https://api.ipify.org?format=json`
   - `https://api64.ipify.org?format=json`
   - `https://ipinfo.io/json`
   - `https://www.cloudflare.com/cdn-cgi/trace`
2. **WebRTC ICE**: `RTCPeerConnection` with `iceServers`
   `stun:stun.cloudflare.com:3478` only. Host, srflx, and relay candidates
   recorded. No TURN. **Zero relay candidates** appeared in this package.
3. **Independent route checks**: Python `urllib` echoes
   (ipify, api64, ipinfo, Mullvad JSON) plus basic `ip route` dumps before and
   after each visit—not the research browser.

Document echoes under proxy conditions were collected with Playwright’s
`APIRequestContext` bound to the same browser context proxy settings. The local
fixture page gathered WebRTC only under proxy conditions after we observed that
in-page `fetch()` through this residential path could hang past `AbortSignal`
(a collector reliability issue, not scored as a privacy finding). Cloud-direct
visits used the full fixture (page fetches + WebRTC).

### Conditions

| ID | Browser proxy | Passes | Notes |
|---|---|---|---|
| `cloud-direct` | none | 2 | USA cloud baseline |
| `proxy-us-http` | ProxySeller residential HTTP | 2 | Native Chromium HTTP proxy + auth |
| `proxy-us-socks` | ProxySeller residential SOCKS5 | 2 | Local anonymizer → SOCKS upstream |
| `proxy-dead` | `http://127.0.0.1:9` | 1 | Fail-closed / fail-open check |

Credentials were read at runtime from Cursor Cloud Agents Runtime Secrets:

- `PROXYSELLER_HOST`
- `PROXYSELLER_HTTP_PORT`
- `PROXYSELLER_SOCKS_PORT`
- `PROXYSELLER_USER`
- `PROXYSELLER_PASS`

Values were never printed into evidence commits. Public records keep country/org
labels, success/error outcomes, candidate types/classifications, opaque address
aliases / SHA-256 prefixes, and secret **presence** / value **lengths**—not raw
IPs or passwords. `env-discovery.json` records HTTP and SOCKS upstream ports as
the same numeric port (`10000`) on this residential package; that is package
configuration metadata, not a browser finding.

### SOCKS authentication guard

A native Playwright `browser.newContext({ proxy: { server: 'socks5://…',
username, password } })` threw:

`Browser does not support socks5 proxy authentication`

That guard is recorded in `chromium-socks-auth-guard.json`. SOCKS visits
therefore used `proxy-chain`’s local anonymizer so Chromium spoke to a local
HTTP proxy without credentials while upstream traffic still used the residential
SOCKS endpoint. The article treats that bridge as an explicit method choice, not
as “native SOCKS5 auth worked in Chromium.”

### Loopback bypass and fixture reliability

Chromium’s bypass token `<-loopback>` *forces* loopback through the proxy. An
early collector revision used that token and caused the local fixture to receive
`503 Target host denied` from the residential gateway; `http-fixture-debug.json`
records a **90 151 ms** wait timeout, zero echoes, and that console error. The
frozen collector uses `127.0.0.1,localhost,<loopback>` so the fixture stays
local while public fetches use the proxy. Screenshots in the package are of that
local fixture UI.

Separately, `playwright-http-smoke.json` shows a successful residential HTTP
smoke (`ok: true`, ~3.1 s, family `v4`, `sha12` `d916dfcb511f`). That smoke hash
differs from the later matrix document-echo hash `8453b223a010`: residential
exits rotated between probe and A1 visits. Probe identity is **not** assumed to
equal matrix identity.

`proxy-connectivity-probe.json` shows urllib HTTP CONNECT succeeded; Python
`requests` and SOCKS helper modules were absent on the host
(`ModuleNotFoundError`), so those alternate client probes are exclusions—not
browser results.

## Visit matrix (all seven)

| Visit | Started (UTC) | Document echoes OK | Document country / org | WebRTC | ICE state | srflx matched proxy document echo? | srflx in cloud-direct address set? |
|---|---|---|---|---|---|---|---|
| cloud-direct p1 | 14:59:26 | 4/4 | US / AS14618 Amazon | host + srflx | timeout | n/a (own-echo match: **no**) | yes (baseline) |
| cloud-direct p2 | 14:59:39 | 4/4 | US / AS14618 Amazon | host + srflx | timeout | n/a (own-echo match: **no**) | yes (baseline) |
| proxy-us-http p1 | 17:48:26 | 4/4 | BR / AS28142 | host + srflx | timeout | **no** | **yes** (`7533c8958c39`) |
| proxy-us-socks p1 | 17:48:42 | 4/4 | BR / AS28142 | host + srflx | timeout | **no** | no (`81fae7bcfd17`; still ≠ proxy echo) |
| proxy-us-http p2 | 17:49:00 | 4/4 | BR / AS28142 | host + srflx | timeout | **no** | no (`e08b95f750df`; still ≠ proxy echo) |
| proxy-us-socks p2 | 17:49:17 | 4/4 | BR / AS28142 | host + srflx | timeout | **no** | **yes** (`dff3fc69aff9`) |
| proxy-dead p1 | 17:49:35 | **0/4** | n/a | host + srflx | timeout | n/a | **yes** (`f53c21c2a17e`) |

HTTP and SOCKS document-echo hashes overlapped each other
(`8453b223a010` on every successful proxy echo URL) and stayed outside the
cloud-direct echo set. Cloud-direct itself showed more than one hashed address
across echo endpoints and passes (datacenter NAT / multi-homing). The
cloud-direct comparison set therefore unions hashed addresses observed on
cloud-direct visits (**size 5** in `sha-relations.json`), not a single immortal
IP.

### Two comparison artifacts (do not conflate)

1. **`sha-relations.json`** — session **union** of cloud-direct document and
   srflx hashes. This is the article’s “srflx in cloud-direct set” column.
2. **`cross-compare.json`** — pass-oriented baseline comparisons
   (`srflxMatchesBaselineEcho`, `srflxMatchesBaselineSrflx`,
   `srflxMatchesOwnEcho`). Example: SOCKS p2 is **in** the session union
   (`dff3fc69aff9` appeared as a cloud-direct p2 *document* echo) while
   `cross-compare` marks both baseline-echo and baseline-srflx matches false
   for that row’s narrower baseline definition.

Authoritative backlink readers should cite the per-visit row and the artifact
name, not a blended “leak rate.”

## Finding 1: HTTP and SOCKS document fetches left the cloud path

Under both ProxySeller HTTP and SOCKS conditions, all four document echoes
succeeded in both passes. ipinfo labeled those exits **BR** /
`AS28142 DIGITAL DESIGN SERVIÇOS DE TELECOMUNICAÇÕES EIRELI`. Cloud-direct
remained **US** / `AS14618 Amazon.com, Inc.`.

Hashed comparisons (`sha-relations.json`):

- Proxy document echoes ∉ cloud-direct address set
- HTTP document-echo hash set ∩ SOCKS document-echo hash set =
  `{8453b223a010}` (same residential identity in this package)
- Cloudflare `trace` country field also returned `BR` under both proxy modes

Interpretation: the browser’s configured proxy path was engaged for these HTTPS
document fetches. A tester who only looked at ipify/ipinfo would conclude the
proxy “worked.”

Illustrative per-URL timings (not SLAs): proxy document echoes completed in
roughly **1.5–2.6 s** per URL via `APIRequestContext`. Cloud-direct page echoes
were typically tens of milliseconds except slower `api64` first contacts.

This study used a purchased residential package for researcher-operated
fixtures. It is not an uptime or speed benchmark of ProxySeller. For
application-level proxy tooling context, see our
[ProxySeller review](/blog/proxyseller-review/) and the affiliate offer at
[/proxyseller/](/proxyseller/).

## Finding 2: WebRTC reflexive candidates never followed the proxy echo

In every proxy visit with successful document echoes (four visits), the WebRTC
server-reflexive candidate **did not match** the proxy document-echo address
(`matchesDocumentEcho: false` on every srflx). Both HTTP and SOCKS produced
exactly one host candidate and one srflx candidate per visit. Host candidates
were classified as non-matching document echoes (local/other). srflx stayed on
a different public identity than the proxied page fetches. No relay candidates
appeared.

Practical risk: a site or “am I protected?” widget that only inspects
`fetch`-visible echoes can report the proxy exit while STUN still learns another
address. That is the core split-path result.

### Baseline caveat (same VM, no proxy)

Even the two cloud-direct visits recorded `matchesDocumentEcho: false` for
their srflx candidates. Cloud-direct p1’s document hashes were
`840349ff1322` / `8036bb026004` / `7533c8958c39` while its srflx was
`f53c21c2a17e` (later seen as a cloud-direct p2 *document* echo). Cloud-direct
p2’s srflx `8036bb026004` matched a prior document echo from p1, not its own
visit’s full echo set. Datacenter multi-homing already disagrees across
surfaces; the proxy findings are stronger because document echoes left the
cloud path entirely while STUN did not follow them.

## Finding 3: Some STUN candidates matched the cloud-direct set

Cross-hashing srflx against the cloud-direct **session union**
(`sha-relations.json`):

| Visit | srflx `sha12` | In cloud-direct set? |
|---|---|---|
| proxy-us-http p1 | `7533c8958c39` | **yes** |
| proxy-us-http p2 | `e08b95f750df` | no |
| proxy-us-socks p1 | `81fae7bcfd17` | no |
| proxy-us-socks p2 | `dff3fc69aff9` | **yes** |
| proxy-dead p1 | `f53c21c2a17e` | **yes** |

Bounded claim: on this VM, WebRTC STUN was **not confined** to the proxy
document-echo identity. In three of five non-baseline visits with an srflx, the
hash reproduced an address also seen on cloud-direct surfaces in this session.
Where srflx fell outside the recorded cloud-direct set, it still mismatched the
proxy document echo—so the split remains even when NAT rotation moves the
exact cloud hash.

We do not pool these into a single “leak rate.” Cloud egress addresses rotated
across the session; treating every mismatch as an independent population event
would overclaim.

## Finding 4: A dead HTTP proxy failed closed for documents, not for WebRTC

With Chromium pointed at `http://127.0.0.1:9`:

- Document echoes: **0/4** succeeded (`documentEchoOk: 0`)
- Error class: `connect ECONNREFUSED 127.0.0.1:9` on every URL (1–11 ms)
- WebRTC: host + srflx still gathered (`iceState: timeout`)
- srflx hash `f53c21c2a17e` ∈ cloud-direct set

That is fail-closed behavior for the HTTPS document path and fail-open behavior
for STUN/UDP relative to the dead HTTP CONNECT proxy. UDP STUN does not ride
the broken HTTP proxy, so the browser still exposed a public reflexive address
while document fetches failed.

Anyone validating “kill switch” style expectations for a *browser HTTP proxy*
must re-check ICE candidates, not only page loads.

## Finding 5: Chromium rejected authenticated SOCKS5 at context creation

The native SOCKS5+auth attempt failed before any navigation:

`browser.newContext: Browser does not support socks5 proxy authentication`

This is a hard error, not a silent direct fallback inside `newContext`. Automation
that needs authenticated SOCKS on Chromium requires a bridge (as we used) or a
different browser stack. We still measured the residential SOCKS upstream through
that bridge; we do not claim Chromium natively spoke SOCKS5 with username/password.

## Finding 6: ICE always timed out; IPv6 never appeared

All seven visits ended with `webrtcIceState: "timeout"` and `webrtcError: null`,
yet each still returned exactly one host and one srflx candidate within the
8-second gather window. Incomplete gathering is therefore the normal outcome in
this package, not an empty candidate set.

Across every successful document echo and every WebRTC candidate, `family` was
`ipv4` / `v4`. `api64.ipify.org` did not yield an IPv6 address here. We make
**no** IPv6 leak claim for this VM; absence of IPv6 is an observation about this
egress and STUN path, not a general network property.

## Methods detail worth reproducing

1. Freeze conditions in `protocol.md` before collection.
2. Discover Runtime Secret **names** with presence-only probes
   (`secret-presence-probe*.json`); refuse proxy conditions if required names
   are absent.
3. Build private `proxies.json` from `os.environ` / `process.env` (gitignored).
4. Record Chromium SOCKS auth guard before bridging.
5. Avoid `<-loopback>` unless you intend to force local fixture traffic through
   the upstream proxy (see `http-fixture-debug.json`).
6. For each visit: route-check → Playwright collect → route-check.
7. Under proxy: document echoes via `APIRequestContext`; WebRTC via local
   `webrtc-only` fixture with loopback bypass.
8. Redact public JSON: strip raw IPs to aliases; keep country/org/typ/classify;
   publish SHA-12 prefixes only.
9. Publish both `sha-relations.json` (session union) and `cross-compare.json`
   (pass-oriented baseline flags); cite which one you used.
10. Keep probe/smoke hashes separate from matrix hashes (residential rotation).

Collector sources live under `research/browser-path-leak-study/`
(`collect.cjs`, `prepare-proxies.py`, `route-check.py`, `run-study.py`,
fixtures). Step-by-step public reproduction notes:
[REPRODUCE.md](/research/browser-path-leak-study/REPRODUCE.md). Fixture
screenshots for each visit are published under
`/research/browser-path-leak-study/screenshots/`.

### Timing notes (illustrative, not SLAs)

| Condition | Typical document echo latency | Visit wall time |
|---|---|---|
| cloud-direct | ~20–110 ms (api64 up to ~2.6 s) | ~10 s |
| proxy HTTP/SOCKS | ~1.5–2.6 s per URL | ~15–17 s |
| proxy-dead | 1–11 ms to ECONNREFUSED | ~8 s |

## What this means in practice

1. **Test more than one surface.** A green IP-echo widget is not a WebRTC test.
2. **Treat STUN/UDP as a separate path** from HTTP(S) proxy CONNECT.
3. **Fail-closed checks must include ICE.** Killing the HTTP proxy stopped
   document echoes here; it did not stop srflx.
4. **SOCKS automation on Chromium** may need a local forwarder when the upstream
   requires username/password.
5. **Expect ICE timeouts** with partial candidates; do not require
   `iceconnectionstate` success as the only success criterion.
6. **A full-tunnel VPN can cover UDP** where a browser HTTP proxy cannot. We did
   **not** prove a CometVPN tunnel on this hosted VM (character-device TUN
   presence alone is insufficient). CometVPN remains VPN-only product context;
   see [/cometvpn/](/cometvpn/) and our
   [CometVPN review](/blog/cometvpn-review/). Do not use CometVPN as HTTP/SOCKS
   credentials.

Related FreePolicyTools reading:
[proxy encryption research](/blog/proxy-encryption-research/),
[consumer portal access research](/blog/consumer-portal-access-research/),
[VPN website protection warnings](/blog/vpn-website-protection-warnings/).

External references for mechanisms (not our measurements):
[MDN RTCPeerConnection](https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection),
[WebRTC ICE overview (IETF)](https://datatracker.ietf.org/doc/html/rfc8445),
[Playwright network proxy docs](https://playwright.dev/docs/network#http-proxy).

## Limits and non-claims

- One Cursor USA VM, one Chromium build, one residential package/account.
- USA cloud datacenter egress is **not** a matched residential control for
  residential proxy exits.
- Kenya/Proton/NetworkManager conditions were intentionally removed.
- CometVPN tunnel behaviour was **not** measured.
- We do not claim provider logging, marketing deception, malware, or
  named-person identification.
- We do not publish a population “leak rate” or competitive ProxySeller uptime
  ranking.
- Cloud NAT rotation means the cloud-direct address set is a session union, not
  a single permanent IP; within-visit document≠srflx already occurs on baseline.
- Document echoes under proxy used Playwright request context; in-page `fetch`
  reliability through this residential path was poor enough that we separated
  WebRTC into a dedicated local fixture for proxy visits.
- Alternate client probes (`requests`, SOCKS helpers) were unavailable on the
  host; their absence is an exclusion, not a browser leak.
- Residential exit hashes rotated between smoke/probe and A1 matrix visits.
- ICE `timeout` with candidates present is incomplete gathering, not proof that
  additional candidate types would never appear with a longer window or TURN.
- No IPv6 was observed; that is not an IPv6-protection claim.

## Evidence, exclusions, and disclosure

Public package under `/research/browser-path-leak-study/`:

- Per-visit redacted JSON (`cloud-direct-p*.json`, `proxy-us-http-p*.json`,
  `proxy-us-socks-p*.json`, `proxy-dead-p1.json`)
- `summary-table.json`, `cross-compare.json`, `sha-relations.json`
- `chromium-socks-auth-guard.json`, `env-discovery.json`, `run-status.json`
- Presence-only secret probes (`secret-presence-probe.json`,
  `secret-presence-probe-node.json`, companion `.txt` listings)
- Collector reliability / probe artifacts (`http-fixture-debug.json`,
  `playwright-http-smoke.json`, `proxy-connectivity-probe.json`)
- `protocol.md`, `sample-frozen.json`, `REPRODUCE.md`, `baseline-status.md`
- Fixture screenshots for all seven visits
- This article (`research-article.md`)

Private (gitignored): raw IPs, credentials, full route dumps, original private
screenshot paths referenced only as private.

**Affiliate disclosure:** FreePolicyTools is a ProxySeller affiliate
([/proxyseller/](/proxyseller/)) and a CometVPN affiliate
([/cometvpn/](/cometvpn/)). We may earn a commission if you purchase through
those links. Affiliate offers are separate from the research findings and do not
change methods, results, or limitations. ProxySeller residential capacity used
here was purchased for FreePolicyTools cloud research. CometVPN is VPN-only
context; this package contains no CometVPN tunnel measurement and does not use
CometVPN as HTTP/SOCKS credentials.

Cite as: FreePolicyTools, “Proxy Connected, Browser Still Direct: WebRTC Left
the Cloud Path Open,” 17 November 2026 (methods/evidence deepened 18 November
2026). Report visits individually. There is no representative user sample,
provider ranking, discovered vulnerability CVE, or evidence of third-party
exploitation.
