What Does a Hyperbeam Proxy Actually Cover?
Configuring a hyperbeam proxy means giving a virtual computer an address its browser dials for HTTP and HTTPS requests. The proxy is one you supply; Hyperbeam passes it into the session. You write it into a PAC script that the browser evaluates through FindProxyForURL, then pick the scheme that matches how your proxy authenticates — HTTPS if it takes a password, SOCKS only if it allowlists by IP.

📌 TL;DR Executive Summary
- Core Takeaway: Hyperbeam proxies are configured through a PAC script. Only HTTP traffic from the virtual browser uses them, and HTTPS is the scheme to pick when the proxy needs a password.
- Key Risk/Challenge: SOCKS authentication is not supported, and a PAC script that returns nothing — or ends with DIRECT — silently sends traffic out on the host address with no error anywhere.
- Recommended Solution: Build the PAC with an ordered, fail-closed fallback, test credentials outside Hyperbeam first, then confirm the exit IP from inside the virtual computer rather than from your laptop.
Where the Proxy Sits in a Hyperbeam Session
Hyperbeam runs a virtual computer in its cloud and streams it into your web app. The Chrome environment inside it runs a Chromium-based browser, so the proxy is applied at the browser’s network layer, not the host’s. Only HTTP traffic is sent through the proxy server and WebRTC traffic is excluded from it — the Hyperbeam proxy FAQ states both plainly.
That sentence resolves most of the confusion. Because the proxy only carries HTTP, SOCKS, HTTP and HTTPS endpoints behave the same functionally from inside the session — the difference is authentication and encryption on the hop, not routing. If you are still choosing an endpoint, SOCKS5 proxy setup covers the provider side.
| Proxy scheme | Authentication inside Hyperbeam | Traffic covered | Use it when |
|---|---|---|---|
| HTTP | Only if credentials are written into the PAC return value | HTTP and HTTPS requests from the virtual browser | You have a legacy endpoint with no TLS support |
| HTTPS | Supported, and Hyperbeam’s recommendation | Same | The proxy needs a password |
| SOCKS4 / SOCKS5 | Not supported — Chromium does not implement it | Same, functionally identical to HTTP | The proxy authenticates by IP allowlist only |
| PAC / FindProxyForURL | Where credentials live; not an auth method itself | Per-host routing rules | You need host rules or a fail-closed fallback |
Two consequences matter. A page that opens a WebRTC connection inside the virtual computer will not exit through your proxy, so an IP check that reads WebRTC addresses proves nothing about the proxy. And a proxy changes the exit address, not the clock or locale inside the session — set those separately if your test depends on them.
How to Configure a Hyperbeam Proxy: Step by Step
Work through these in order. Each step ends with a check you can run before moving on, because a proxy fault inside a streamed virtual computer is far harder to diagnose than one on your own laptop.
- List the hosts that must exit through the proxy. Write down the app you are showing, the API behind it, the login redirect and the asset CDN. Note which must appear to come from a particular city. Leave WebRTC off the list entirely. Check: the list holds host names, not “everything”, because you are about to encode it as PAC rules.
- Choose HTTPS if the proxy needs a password. Hyperbeam recommends HTTPS to authenticate and secure the link between its servers and your proxy. SOCKS is the exception: authentication is not supported because Chromium does not implement it, so a SOCKS5 endpoint that demands a password will not authenticate. Check: ask your provider whether the endpoint accepts TLS to the proxy, plaintext only, or IP allowlisting.
- Test the credentials outside Hyperbeam first. Confirm the exact username, password, host and port from your own machine:
curl -x https://proxy-user:[email protected]:8443 -s -o /dev/null -w "%{http_code}" https://example.com
A 200 means the credentials and the port are right. Check: a 407 is a credential problem, a timeout is a firewall or port problem. Fix both here, before you touch the session. - Write the PAC script. A return value is one of DIRECT, PROXY host:port, SOCKS host:port or HTTPS host:port, and you can return several separated by semicolons — the browser tries them in order.
function FindProxyForURL(url, host) { var primary = "HTTPS proxy-user:[email protected]:8443"; var backup = "HTTPS proxy-user:[email protected]:8443"; host = host.toLowerCase(); // Windows WinHTTP does not lower-case for you if (isPlainHostName(host) || host === "localhost") { return "DIRECT"; } if (shExpMatch(host, "*.internal.example.com")) { return "DIRECT"; } // Ordered list, no trailing DIRECT: a dead proxy must fail loudly // instead of quietly falling back to the host address. return primary + "; " + backup; }Check: every proxy entry carries a port — a missing port produces a rule the browser cannot use.
- Apply the PAC when the session is created. Sessions are created from your backend through Hyperbeam’s REST API, and the NPM package on the frontend loads and controls the computer that results. Set the proxy at session level so every participant inherits the same network path; the exact field name is in the session-create reference, and the point is that it is per session, not per participant. Check: join from two accounts and confirm both report the same exit IP.
- Make failure loud. A PAC script that throws or returns nothing makes Chromium connect directly, with no error shown; ending the list with DIRECT does the same when the proxy dies. If the proxy is the point of the session, fail closed. Check: stop the proxy for a minute on purpose. If pages still load, your fallback is wrong.
- Verify from inside the virtual computer. Open two independent IP-check pages in the session, not on your laptop, and compare the address and city against the proxy’s documented exit and Hyperbeam’s server region. Then open the app you care about and read the account, currency or locale it shows. Check: both IP pages agree; if one reports the proxy and the other a different network, you have split routing.
host argument at the top of the function and the same PAC script behaves identically across every engine that runs it.
Where Proxy Credentials Go — and Where They Must Not
Every proxy password in a PAC script travels with the session definition. Treat it like any other secret in your stack.
Put the credential in the return value, not in url
Chromium-based engines strip the path and query of https URLs before the PAC script sees them, and Chromium and Windows also remove the user name and password, while Firefox keeps them. A script that parses credentials out of url therefore works in one engine and returns an empty string in another. Write the password into the string you return.
Encrypt the hop to the proxy
With an HTTPS proxy the client speaks TLS to the proxy itself, so credentials and the request line are encrypted on that first hop. A plain HTTP proxy sends both in the clear, which is why Hyperbeam recommends HTTPS for authenticated proxies. If your provider only offers HTTP, restrict it by IP allowlist so the password is not your only control.
Assume the script will be read
If your integration ships the PAC to the client, anyone with devtools can read it. Keep the credential server-side, inject it at session creation, and rotate it on a schedule you can keep. A password that appears in a support ticket or a screen recording is a password you have to replace.
Proxy Authentication Is Not Participant Authentication
These two get mixed up constantly. Proxy authentication proves the virtual computer may use your proxy. Participant authentication proves a person may connect to the virtual computer. They are configured in different places and fail differently; one can work perfectly while the other is broken.
The default: a webhook on every connection
Hyperbeam’s default participant authentication is a webhook. When a new user connects, the virtual computer sends a POST to your endpoint with a JSON body containing user_id and userdata, plus Authorization: Bearer <token>, HB-User-Agent and HB-Connection-IP headers. Returning 200 with {"authorized": true} grants access; any non-200 status, or a 200 without the authorized key, denies it.
The same response can carry a permissions object, which sets that user’s permissions atomically instead of in a second call — useful once a session has participants with different rights. The full contract is in Hyperbeam’s participant authentication guide.
Token authentication and the embed URL
Token authentication appends a token as a query parameter on the embed URL, so only holders of that URL reach the computer rather than anyone who learns the session ID. Treat embed URLs as secrets; they end up in screenshots, tickets and chat threads.
For proxy work, the split tells you where to look. A proxy fault shows up as a network error or a reset connection inside the session. A participant fault shows up as a denied connection or an embed that never starts.
Pitfalls That Break a Hyperbeam Proxy Setup
Most failures here are silent. The session looks fine, pages load, and traffic is going somewhere you did not intend.
The return list ends with DIRECT — or returns nothing
DIRECT at the end looks like a friendly fallback and is the most common way a proxy quietly stops being used: when it dies, the browser connects from the host address instead. A script that throws or falls off the end does the same in Chromium and Firefox, with no error. Always end on a proxy entry.
SOCKS5 with a password
The password is ignored because the authentication step is not implemented, so the connection either fails or goes through unauthenticated. If your provider offers SOCKS5 with credentials, ask for the HTTP or HTTPS endpoint instead.
Host comparisons break on case
Chromium, Edge and Firefox lower-case the host before calling FindProxyForURL; Windows WinHTTP does not, so a rule matching “App.Example.com” passes on one path and fails on another. Lower-case the argument at the top of the function and the ambiguity disappears.
Expecting WebRTC to follow the proxy
It will not. Anything a page does over WebRTC travels outside the proxy entirely, so a test built on a WebRTC-reading IP checker will draw the wrong conclusion about a proxy that works. When the embed itself misbehaves rather than the network, fixing a broken Hyperbeam embed is a better first step than a rebuild.
Rotating Proxies and Long-Lived Sessions
Two features interact badly: save states and proxy rotation. Hyperbeam supports session save states, so a virtual computer can be stopped and restored rather than rebuilt. If the proxy behind it rotates to another country while that state is alive, the app inside sees one login from one place and later requests from another — usually a fresh verification step and a support ticket.
Pin a sticky proxy session for as long as the saved state exists, and rotate between sessions rather than inside one. Log the exit IP at creation time so you can match a saved session to the proxy that served it. If you genuinely need per-request rotation, expect the session to look like a new device every few minutes and design for that: a public demo page, a QA pass, a documentation screenshot — not a logged-in account you are authorised to manage. Rotating proxy setup covers those patterns in more depth.
Outside an embed, the same discipline is a product setting rather than a script: Send.win gives each isolated browser profile its own cookies, storage, fingerprint settings and proxy, so a sticky exit IP belongs to the profile instead of a PAC file you maintain.
Post-Deployment Checklist
Run these after every change to the session configuration, not only on launch day.
- Two IP checks inside the session agree with each other and with the proxy’s advertised exit.
- The proxy dashboard shows requests at the time you opened the session — proof authentication was accepted, not merely attempted.
- The fail-closed drill passes. Kill the proxy; the session should break rather than fall back to the host address.
- Participant auth still denies the wrong token and allows the right one.
- No credential appears in the built frontend bundle, in logs, or in error output.
- A restored save state still exits through the expected proxy.
- Any IP allowlist on the proxy contains Hyperbeam’s current server ranges, confirmed recently rather than copied from a forum post.
🏆 Send.win Verdict
If your job is embedding a virtual computer inside a product, Hyperbeam is the right layer and Send.win is not a substitute — Send.win is a browser profile manager for people and teams working on their own machines, not a runtime you embed in an app. It solves the adjacent problem: a team that needs isolated browser profiles on their own desktops, each with its own cookies, storage, fingerprint settings and proxy, shareable with paid teammates so a shared profile opens already signed in. Proxy handling is per profile, residential proxies are included on Pro and Team, and timezone, locale, WebRTC and geolocation follow the proxy’s exit IP with no PAC script to maintain.
See Send.win plans — plans from $19/mo with a 7-day money-back guarantee on your first card purchase, or try the free cloud demo with 10 minutes a day and nothing to install.
Frequently Asked Questions
Does a Hyperbeam proxy support SOCKS5 authentication?
No. Hyperbeam’s documentation states that authentication is not supported for SOCKS because Chromium does not implement it. A SOCKS5 endpoint that demands a username and password will not authenticate from inside the virtual computer. Use an HTTPS proxy when you need credentials, or restrict the SOCKS proxy by IP allowlist instead.
Where do proxy credentials go in Hyperbeam’s FindProxyForURL?
In the string the function returns, alongside the host and port. Do not read them back out of the url argument: Chromium and Windows strip the user name and password from that URL before the script runs, while Firefox keeps them. Keep the credential server-side and inject it when the session is created.
Why is only HTTP traffic sent through the Hyperbeam proxy?
Because the proxy setting lives in the browser’s network layer, and Hyperbeam excludes WebRTC traffic from it. SOCKS, HTTP and HTTPS therefore behave the same functionally inside the session. The practical effect is that a WebRTC connection opened by a page will not exit through your proxy, so an IP check based on WebRTC does not prove the proxy works.
Which proxy protocol does Hyperbeam recommend?
HTTPS, when the proxy requires authentication and you want the link between Hyperbeam and the proxy encrypted. Plain HTTP proxies still work but send credentials over that hop in the clear. SOCKS works without authentication but cannot take a password at all.
Why did traffic go direct even though the proxy was configured?
Two common causes. The PAC script threw an exception or returned nothing, which makes Chromium connect directly without any error, or the return list ended with DIRECT, so a dead proxy quietly became your own connection. Remove the DIRECT tail, return only proxy entries, and test by stopping the proxy on purpose.
Can I allowlist Hyperbeam’s server IP ranges on my proxy?
Hyperbeam’s FAQ covers IP range whitelisting, which is the usual alternative to password authentication. Ask Hyperbeam for the current outbound ranges before you lock down a firewall, because a stale allowlist fails silently at the worst possible moment — usually during a demo.
How do I fix CORS errors when embedding a Hyperbeam session?
CORS is enforced by the browser, not by the proxy, so changing the proxy rarely fixes it. The error usually comes from your own API or asset origin not allowing the embed’s origin. Check the allowed origins on your backend first, and only then investigate the network path.
How is participant authentication different from proxy authentication?
Participant authentication decides which people may connect to the virtual computer — a webhook returning {"authorized": true}, or a token appended to the embed URL. Proxy authentication decides whether the virtual computer may use your proxy at all. They fail in different places, so diagnose them separately before changing either configuration.
How Send.win Helps With Hyperbeam Proxy
Send.win is a browser profile manager for professionals and teams: every account gets its own isolated browser profile.
- Isolated profiles – separate cookies, storage and sessions per profile
- Fingerprint protection – each profile keeps its own consistent browser fingerprint, so profiles never share one browser identity
- Desktop app + cloud browser – native app for Windows, macOS and Linux, or run profiles in the cloud with no install
- Residential proxies included – on Pro and Team, with timezone and locale matched to the proxy
- Team sharing – share a signed-in profile with a teammate without sharing the password
Try the free cloud demo — no install — or download the desktop app. Paid plans start at $19/month, and your first card purchase is covered by a 7-day money-back guarantee (see pricing).