← back to blog

SOCKS5 Or HTTP: Picking The Protocol Inside A Browser Profile

Every antidetect browser profile has a small dropdown next to the proxy fields. HTTP, HTTPS, SOCKS5, sometimes SOCKS4. Most providers hand you the same exit on two ports, one for each protocol, and most operators pick one at random, or pick SOCKS5 because someone on a forum said it was more anonymous.

The choice matters less than forum lore suggests and more than people who ignore it assume. Both protocols can route a browser’s web traffic through the same exit, and a platform looking at your requests usually can’t tell which one you used. The differences show up at the edges: where DNS gets resolved, what happens to traffic that isn’t a normal web request, and what the proxy is able to see or add along the way. Those edges are exactly where leaks come from.

This piece is about that dropdown. The question of which kind of exit to buy, residential or mobile or datacenter, is a separate one. Here the exit is fixed and we’re choosing how the profile talks to it.

What an HTTP proxy carries

An HTTP proxy understands web requests. It speaks the same language as the websites you visit, and it handles the two kinds of web traffic in two different ways.

For a plain http:// address, the browser sends the whole request to the proxy, including the full URL and every header. The proxy reads it, makes the request to the website itself, and passes the response back. It can see everything, and it can change anything, including adding headers of its own.

For an https:// address, which is nearly all of the modern web, the browser sends a CONNECT request instead. That request names the host and port it wants, something like “connect me to example.com on port 443”. The proxy opens a TCP connection to that host and from then on just shuttles encrypted bytes back and forth. It can see which host you connected to, because you told it, but not the pages or the content, because the TLS encryption runs directly between your browser and the website.

So for secure sites, an HTTP proxy is acting as a tunnel. It’s HTTP only in the sense that the tunnel is requested using HTTP.

There’s also “HTTPS proxy” in some dropdowns, which usually means the connection from your browser to the proxy is itself encrypted with TLS. That protects the CONNECT request and any proxy credentials on the first hop. It doesn’t change what the website sees.

What a SOCKS5 proxy carries

SOCKS5 works a layer lower, relaying connections without reading the web requests inside them. It’s a general-purpose relay: the client says “open a connection to this address and port”, the proxy does it, and from then on it forwards bytes in both directions without caring what they are.

That makes it protocol agnostic. Web traffic, mail, chat protocols, anything that runs over TCP can go through a SOCKS5 proxy without the proxy needing to understand it. For a browser, that mostly doesn’t matter, since browsers speak HTTP and HTTPS. It matters for other tools that might share the same proxy settings.

SOCKS5 also defines a way to relay UDP, called UDP ASSOCIATE, which HTTP proxies have no equivalent for. In principle, that means SOCKS5 can carry traffic HTTP proxies can’t. In practice, as we’ll see, browser support for sending UDP through SOCKS5 is limited, and many providers don’t implement it on their servers anyway.

The other important feature is how SOCKS5 handles addresses. The client can hand the proxy a hostname and let the proxy resolve it, or resolve the hostname itself and hand over an IP address. That one detail decides whether your DNS lookups travel through the proxy or leak out through your own network.

SOCKS4 is an older version with no authentication, no IPv6 and, in its original form, no hostname support. There’s rarely a reason to pick it for profile work today.

DNS: who looks up the address

Before a browser can connect to a website, something has to turn the hostname into an IP address. Where that lookup happens is one of the most practical differences between the two protocols.

With an HTTP proxy, the browser gives the proxy the hostname, either in the CONNECT request or in the full URL. The proxy does the DNS lookup on its own side. Your machine doesn’t need to resolve the name at all. DNS stays with the proxy by design.

With SOCKS5, it depends on the client. If the browser sends the hostname to the proxy, the proxy resolves it and DNS stays remote. If the browser resolves the name locally first and sends only the IP address, the lookup goes through your own network’s resolver, usually your ISP’s or whatever DNS server your machine is set to.

Command-line tools make this visible. In curl, socks5:// resolves locally and socks5h:// sends the hostname to the proxy. The h stands for hostname, and forgetting it is a classic mistake.

Browsers vary. Chromium-based browsers send hostnames through SOCKS5 proxies for remote resolution. Firefox has a specific setting to proxy DNS when using SOCKS5, and it’s worth checking rather than assuming its value in whatever version you run. Antidetect browsers generally resolve remotely, but it’s a claim you should test yourself.

Why it matters is covered next. For now, the short version is that with HTTP the question barely arises, and with SOCKS5 you need to confirm it.

Why a DNS leak matters

A local DNS lookup doesn’t reveal your IP address to the website. The site still sees the proxy’s exit. So why care?

Because the lookup goes somewhere. It reaches your ISP’s resolver, or a public resolver you configured, and from there it reaches the authoritative DNS servers for the website’s domain. Large platforms often run their own authoritative DNS, or can see where lookups for their domains come from. If the lookups for a profile that exits in Singapore consistently arrive from a resolver in another country, that’s a mismatch between two views of the same visit.

DNS leak test sites exploit exactly this. They make your browser look up a unique hostname, then check which resolver asked their DNS server for it. If the resolver belongs to your home ISP while your IP belongs to the proxy, you’ve got a leak, and the test page will show it plainly.

How much platforms use this is unknown from the outside. Some probably don’t. But the check is cheap for anyone who controls a domain’s DNS, and it’s one of the few signals that can connect a proxied session to the operator’s real network rather than just flagging it as proxied.

There’s also a privacy angle unrelated to platforms. A local lookup tells your ISP, or your configured DNS provider, which sites your profiles visit. If keeping your own identity separate from the fleet matters, DNS is part of that.

The fix is simple once you know to look. Use a protocol and setting where DNS resolves remotely, then run a leak test in the profile to confirm.

UDP, and why HTTP proxies can’t carry it

HTTP proxies carry TCP connections and nothing else. Every CONNECT tunnel is a TCP stream. There’s no way to send a UDP packet through an HTTP proxy.

Most web traffic is TCP, so that usually doesn’t matter. But a growing slice of traffic uses UDP, and the question is what happens to it when the browser has only a TCP proxy to work with.

The biggest example is HTTP/3, which runs over a UDP-based transport called QUIC. Browsers generally don’t use QUIC through an HTTP or SOCKS proxy. When a proxy is configured, they fall back to HTTP/2 or HTTP/1.1 over TCP. That’s normal, sites handle it, and plenty of real users sit behind networks that block QUIC. You shouldn’t try to force it.

The second example, and the one that causes real leaks, is WebRTC. It’s the browser feature behind video calls and some peer-to-peer functions, and it prefers UDP. It also has its own way of discovering your network addresses, which it does independently of the proxy settings. That’s the subject of the next section, because it’s where the protocol choice meets the most common leak in browser profiles.

The third example is DNS itself, which traditionally runs over UDP. With remote resolution through the proxy, that doesn’t matter. With local resolution, the lookup leaves your machine as ordinary UDP to your resolver.

The point is that neither proxy protocol, as browsers use them, reliably carries UDP. So everything that wants UDP has to be handled some other way: disabled, forced onto TCP or masked by the browser.

WebRTC over each protocol

WebRTC is designed to connect two browsers directly, and to do that it gathers every address it might be reachable on. It asks the operating system for local network addresses, and it contacts STUN servers over UDP to learn the public address its traffic appears from. Those addresses become “candidates” that a web page can read.

If a STUN request goes out over UDP directly, bypassing the proxy, it reveals your real public IP. A page can collect that candidate and compare it with the proxy address it sees in the HTTP request. That’s the classic WebRTC leak, and it happens whether the profile uses HTTP or SOCKS5, because browsers don’t send those UDP requests through either one.

SOCKS5’s UDP support doesn’t rescue this in practice. Browsers generally don’t route WebRTC’s UDP through SOCKS5, and many proxy servers don’t implement the UDP relay part of the standard.

What fixes it is browser-level policy. Chromium has settings that control which interfaces WebRTC may use, including one that forbids UDP that doesn’t go through the proxy, which effectively forces WebRTC onto proxied TCP or stops it gathering the real address. Antidetect browsers usually give you a WebRTC option per profile: disable it, replace the reported addresses with the proxy’s, or let it through. Disabling can look odd, since almost every real browser has WebRTC. Replacing the addresses with the proxy exit is the common middle choice.

Whatever you pick, test it. A WebRTC leak test page will list the candidates your profile exposes. The only public address on that list should be the proxy’s.

What the proxy can add or reveal

A proxy isn’t always a silent pipe. What it can do to your traffic depends on the protocol and on whether the site uses encryption.

On plain http:// pages through an HTTP proxy, the proxy can add headers. Some proxies add a Via header naming themselves, or an X-Forwarded-For header containing your original IP address. Proxies that do this used to be called transparent proxies, and a site reading those headers would see straight through to you. Reputable paid providers don’t add them, but cheap or misconfigured ones can, and the only way to know is to test.

On https:// pages, the proxy can’t add anything, because it’s only tunnelling encrypted bytes. That’s a big part of why the leak risk from headers has faded: most of the web is encrypted now.

SOCKS5 never adds headers, because it doesn’t understand HTTP.

There’s also what the proxy can observe. An HTTP proxy sees the full URL on plain HTTP and the hostname on HTTPS. A SOCKS5 proxy sees the destination address and port, and the hostname too if you use remote resolution. Neither sees the content of HTTPS pages. In both cases you’re trusting the provider with a list of the sites your profiles visit, which is one more reason to care who runs your proxies.

To check for added headers, open a plain http:// header echo page in the profile and read what arrives. If you see your real IP in any header, stop using that proxy.

The layers the protocol doesn’t change

It’s worth being clear about what the dropdown can’t affect, because people sometimes switch protocols hoping to fix a problem that lives somewhere else.

The exit IP is the same either way. If the address is flagged, or belongs to a hosting company, or sits in the wrong country, switching from HTTP to SOCKS5 changes nothing the website cares about.

The TCP connection to the website starts at the proxy server in both cases. So low-level characteristics of that connection, the kind that tools use to guess the operating system from packet details, belong to the proxy’s machine, not yours. If the profile claims Windows and the connection’s packet signature looks like a Linux server, that mismatch exists regardless of protocol. Mobile and residential setups where the exit is a real device handle this differently, but the protocol choice doesn’t.

The TLS handshake, on the other hand, runs from your browser to the website through the tunnel. The proxy doesn’t touch it with either protocol, so the TLS fingerprint the site sees comes from your browser in both cases. That’s a separate topic, and the proxy protocol won’t fix or break it.

The browser fingerprint, cookies and account behaviour are all above this layer entirely.

So if a profile is getting flagged, the protocol is rarely the cause. Check the exit, the DNS and WebRTC before blaming the dropdown.

Speed and reliability

People sometimes pick SOCKS5 because they’ve heard it’s faster. The honest answer is that the protocol overhead is small in both cases, and differences you notice in practice come from the provider’s servers and network, not from the protocol.

A SOCKS5 connection needs a short handshake before the first byte flows, and with authentication a couple of extra round trips. An HTTP CONNECT tunnel needs one request and one response. Both are tiny compared with the TLS handshake that follows and the time spent loading a page. Once the tunnel is open, both just forward bytes.

Where you might see a difference is in connection reuse. Browsers keep connections open and reuse them for many requests to the same site. Through either protocol, that works the same way, since the reuse happens inside the tunnel.

Reliability is more about implementation. Some providers run their HTTP and SOCKS5 services on different software, and one may be better maintained than the other. If one port gives you frequent resets or timeouts and the other doesn’t, that’s your answer for that provider, even if the reason is invisible.

What I wouldn’t do is switch protocols on a live profile to chase a speed difference. The exit stays the same, but you’re changing a setting on an account that’s been working, and a change you can’t measure is a poor trade for any risk at all.

Other tools that share the settings

A browser profile rarely lives alone. The same proxy might be used by a scraper, a mail client, an automation script or a desktop app, and the protocol choice matters more for those than for the browser.

Non-web protocols need SOCKS5. An HTTP proxy can technically tunnel anything over CONNECT, but many HTTP proxies restrict CONNECT to port 443, the HTTPS port, so a mail client trying to reach port 993 or 587 gets refused. SOCKS5 has no such concept and will relay any TCP port the provider allows.

Some desktop apps only support one type. Many older tools and some scrapers support HTTP proxies and nothing else. Some chat apps support SOCKS5 only. Check before you commit a whole fleet’s configuration to one protocol.

Command-line and scripting tools vary in their DNS behaviour. As mentioned, curl needs socks5h to resolve remotely. Python libraries that support SOCKS usually have an equivalent distinction, often the same h suffix in the proxy URL. A script that resolves locally is leaking DNS even if the browser profile it runs alongside isn’t.

System-wide proxy settings on an operating system usually support both, but applications decide for themselves whether to honour them. Many ignore them entirely.

The rule is to check each tool separately. A setting that works cleanly in the browser tells you nothing about the script next to it.

Misconfigurations that look like dead proxies

A surprising number of “the proxy is down” problems are really a protocol mismatch between the profile and the port. They’re worth recognising, because the symptoms send people chasing the wrong fix.

The most common is the wrong type on the right port. Providers often run HTTP on one port and SOCKS5 on another. Set a profile to SOCKS5 and point it at the HTTP port, and the handshake bytes arrive in a format the server doesn’t expect. Depending on the software, you get an immediate reset, a hang, or a garbled error. Set it to HTTP on a SOCKS port and the server receives a CONNECT line it can’t parse. Either way the profile reports a connection failure that looks exactly like an offline exit.

The second is SOCKS4 selected by accident. Some dropdowns list it first. SOCKS4 has no username and password support, so an authenticated proxy will refuse it, and the error message rarely says why.

The third is credentials in the wrong place. Some tools want the proxy as a single URL with the username and password embedded, others want separate fields, and pasting a full URL into the host field produces a hostname that can’t resolve.

The fourth is special characters in passwords. A password with an @ or a colon breaks URL-style proxy strings unless it’s encoded, which is a common reason one teammate’s setup works and another’s doesn’t.

When a new profile won’t connect, check these before assuming the exit is dead. Confirm which port speaks which protocol in the provider’s documentation, set the type explicitly, and test with a simple command-line request using the same settings. If the command line works and the profile doesn’t, the problem is in the profile’s configuration, not the proxy.

Phones and the protocol question

On Android the protocol question looks different, because the tools are different.

The built-in proxy setting in a phone’s Wi-Fi configuration is an HTTP proxy. You give it a host and a port. There’s no SOCKS option and no field for credentials. Apps are supposed to respect it, but they don’t have to, and some talk to their servers directly regardless. So on a phone, the system HTTP proxy is a partial solution at best.

To use SOCKS5 on Android, people usually install a proxy client that creates a local VPN interface on the device and pushes traffic through it to the SOCKS5 server. That changes the picture in two ways. First, it captures traffic from every app, not just the ones that respect the system proxy, which is better for consistency. Second, it can see UDP traffic too, and what it does with UDP depends on the client and the server. If the server supports SOCKS5 UDP relay, the client may send it through. If not, the client may drop it or, worse, let it go out directly.

Some apps also check whether a VPN interface is active, and a phone that always has one running is a little different from an ordinary handset. Whether that matters depends on the app.

The cleanest arrangement for phones is often to avoid device-level proxy settings entirely: a phone on its own mobile data connection, or a network where the proxy is applied upstream so the phone just sees ordinary internet access. That’s one reason hosted phone setups tend to handle the network outside the device.

If you do run a proxy client on a phone, run the same leak tests in the phone’s browser that you’d run in a desktop profile, and check what happens to a voice or video call in the apps you use, since those are the UDP-heavy features most likely to escape.

Chains, converters and mixed setups

Sometimes the protocol a tool needs isn’t the one the provider offers, or you want a local layer between your tools and the provider. That leads to chains: a local proxy that accepts one protocol and forwards onward in another.

A common example is a local HTTP proxy that forwards to an upstream SOCKS5 server, so tools that only speak HTTP can use a SOCKS-only provider. Another is a local SOCKS5 listener that forwards to an authenticated HTTP proxy, so a tool that can’t handle credentials connects to localhost and the forwarder adds them.

Chains work, but every hop has its own DNS behaviour, and the chain is only as clean as its leakiest link. If the local forwarder resolves hostnames itself before passing traffic on as IP addresses, your DNS goes out through your own network even though the tool and the upstream proxy would both have resolved remotely. Read the forwarder’s documentation for how it handles hostnames, and test the whole chain end to end, not each piece separately.

Each hop also adds a place for things to fail and a place for credentials to be stored. Keep chains short. One local forwarder in front of the provider is manageable. A laptop proxy feeding a server proxy feeding the provider is a debugging session waiting to happen.

And check the bind address of any local proxy you run. A forwarder listening on all interfaces is an open proxy for everyone on your network, whatever protocol it speaks.

How to choose

With all of that laid out, the decision gets fairly short.

For a browser profile doing ordinary web work, either protocol is fine as long as DNS resolves remotely and WebRTC is handled. HTTP gives you remote DNS automatically. SOCKS5 gives it to you if the browser sends hostnames, which antidetect browsers and Chromium generally do, but you need to confirm it.

If the provider offers both, I’d lean towards whichever one the provider documents as its main product, since that tends to be the best maintained. Beyond that, pick one and be consistent across the fleet, so every profile behaves the same way and troubleshooting has one path.

Choose SOCKS5 when the same credentials serve non-web tools, like mail clients, or when a tool you depend on only supports it.

Choose HTTP when tools in the stack only support HTTP, or when you need the simplest possible configuration for tools that can’t handle SOCKS authentication.

Consider an encrypted connection to the proxy, the “HTTPS proxy” option, if your provider supports it and you work from untrusted networks. It protects your credentials on the first hop.

And don’t change a working profile’s protocol without a reason. A profile that has been stable on one setting has nothing to gain from a switch.

A test routine for any profile

Whatever you choose, test the profile before any account uses it and again after any change to its proxy settings. It takes a few minutes.

Open an IP lookup page and confirm the address, owner and location match the exit you expect.

Open a DNS leak test and confirm that the resolvers it reports belong to the proxy side, or at least not to your home ISP. If your own ISP shows up, DNS is resolving locally, so fix the protocol or setting and test again.

Open a WebRTC leak test and read the candidate list. The only public IP should be the proxy’s. Local network addresses may be hidden or shown depending on your settings. Your real public address should never appear.

Open a plain http:// header echo page and check that no header contains your real IP or names a proxy you didn’t expect.

Note the results in the profile’s record, with the date. If something later goes wrong, you’ll want to know what the profile looked like when it was last known to be clean.

If any test fails, don’t let the account log in until it passes. A leak on first contact is recorded, and that record is hard to shake.

The honest limit

The protocol dropdown is one small setting among many, and getting it right removes a few specific leaks. It doesn’t make a profile undetectable, and it doesn’t turn a bad exit into a good one.

What’s known is how the protocols work: where DNS goes, what can carry UDP, what a proxy can add. What’s much less known is how much any particular platform uses DNS resolver location or WebRTC candidates in its scoring. Some clearly check WebRTC, because it’s trivial. DNS is harder to see from the outside. The sensible move is to close both, since closing them costs nothing.

I run Singapore mobile proxy farms myself, and customers ask about this dropdown more than almost anything else. The answer I give is the one above: pick either, confirm DNS is remote, handle WebRTC, and test before an account ever logs in. For the rest of the proxy setup, from picking the right exit type to catching the leaks this piece touched on, start on the Multi Account Ops home page.

Get new guides and videos first — join the Telegram channel.

need infra for this today?