← back to blog

When your proxy drops in the middle of a session

Why a small stall can be an expensive mistake

A proxy drop in the middle of a session looks small while it’s happening and costs you afterward. You’re halfway through a warm-up routine, the page stalls for a few seconds, and then everything carries on as if nothing happened. Nothing on your screen tells you that the platform just watched a logged-in account appear from a different network, or from your home connection, or from nowhere at all for forty seconds.

I run Singapore proxy and cloud-phone farms and manage large account fleets, so I treat drops as a routine operational fact, not a rare accident. Modems reboot. Carriers reassign addresses. Upstream providers have bad minutes. A laptop hops between Wi-Fi networks. Your proxy will drop. What matters is what your stack does in the seconds that follow, and whether the platform gets to see anything it shouldn’t.

This article is the deeper companion to the video on the same topic. It covers what a drop actually is at the network level, what a platform can observe, why some drops are harmless and others aren’t, how antidetect browsers and proxies interact when the tunnel dies, and how to build a setup that fails closed instead of failing open. There’s a worked example with a realistic failure shape, a list of edge cases that catch experienced people, and a Monday checklist at the end.

One honest caveat before we start. Nothing here guarantees an account survives. Platforms weigh many signals, and a clean network path is only one of them. What I can describe is how to remove one avoidable class of mistakes, and how to recognize when a session has been compromised so you make a calm decision instead of a hopeful one.

Four things people call a drop

“My proxy dropped” covers at least four different events, and they have very different consequences. Sorting them is the first skill.

The first is a hard drop. The proxy refuses connections or resets them. The browser shows a connection error, pages fail to load, and nothing reaches the platform at all. This is the best kind of failure, because the platform sees silence. A user whose connection went out looks exactly like this.

The second is a soft stall. Packets are delayed, connections hang, requests time out after thirty seconds or more, and then sometimes recover. The session may resume on the same exit IP. Usually that’s harmless, but it can produce duplicate requests or half-completed actions, like a post that was sent twice or a form that submitted without the page updating.

The third is an exit change with the tunnel still alive. The proxy connection stays up, but the IP the platform sees is different. This happens when a rotating residential pool reassigns you, when a sticky session expires, or when a mobile modem reconnects and gets a new address. Your client sees no error at all. It’s the quietest failure and often the most overlooked.

The fourth is a leak. The client loses the proxy and falls back to a direct connection, or some traffic never went through the proxy in the first place. The platform now sees your real network, tied to a session that had been coming from somewhere else.

The first two are interruptions. The third is an identity event. The fourth is an exposure. Most advice treats all four as “reconnect and carry on,” and that’s where people get hurt. Your monitoring and your response should be different for each, and the rest of this article is organized around that difference.

The practical way to tell them apart is to look at two things after the event: did the client report an error, and is the exit address the same as before? Errors with the same address afterward point to the first two. No errors with a different address is the third, and it’s the one you’ll only catch if something is actually comparing addresses. A page that loads while your echo check shows your real network is the fourth. If you’re not recording the exit address at intervals, you can’t distinguish any of these after the fact, and you end up guessing.

What the platform can actually observe

A platform doesn’t see your proxy. It sees connections arriving at its servers, each carrying a source IP, a TLS handshake, headers, and whatever tokens your browser presents. The session itself lives in cookies or tokens, not in the IP. That’s why a login can survive an IP change: the server recognizes the token, then decides how much weight to give the new address.

What’s logged is usually the IP at login and often the IP on later requests. From an address, a platform can derive a rough location, the network operator, and the type of network, such as mobile carrier, residential ISP, hosting provider, or known proxy range. These lookups come from commercial and internal databases and they’re imperfect, but they’re good enough to spot large jumps.

So when an exit changes mid session, the platform can compare the before and after. A jump from one Singapore mobile address to another address on the same carrier is a small change. A jump from a Singapore carrier to a residential ISP in another country, inside one continuous session with an unchanged browser fingerprint, is a large one. The fingerprint staying constant is itself informative: same device, different network, within minutes.

Notice what this means for the token. Because the session cookie keeps working across the change, nothing breaks on your side. You get no logout, no error, no warning. The evaluation happens on the server, after the fact, and you’re never told the result. A session that appears to be running normally is not evidence that the change went unnoticed.

I don’t know any platform’s thresholds, and anyone who states them confidently is guessing. What I can say from running fleets is that the possible responses form a ladder: nothing, a silent risk score adjustment, a re-authentication prompt, a verification challenge, a temporary restriction, and eventually a ban. You don’t get to see which rung you triggered, and effects can show up days later. That delay is exactly why prevention beats diagnosis here.

Why continuity matters more than the address

It’s tempting to think the goal is a “good IP.” For a long-lived account, the better goal is a consistent story. Real people do change networks. A phone moves from home Wi-Fi to cellular when someone walks out the door. A laptop goes from an office to a café. Platforms have to tolerate that or they’d lock out ordinary users constantly.

What makes real network changes look ordinary is their shape. The device is the same, the country is usually the same, the change often happens at a natural break such as app open or wake from sleep, and the new network is a plausible kind for that device. A phone on a cellular carrier switching to home broadband in the same city is boring.

What makes a proxy failure look unusual is the opposite shape. The change happens in the middle of activity, with no natural break. The network type can flip from mobile to hosting range. The location can jump. And the browser’s own signals, like time zone and language, may now disagree with the address, which I’ll come back to.

So when you design for drops, think in terms of keeping the story coherent. Staying on the same carrier family, the same city, and the same network type matters more than staying on the identical IP. And when coherence can’t be kept, ending the session cleanly is better than limping on. A session that stops looks like a person who closed the app. A session that changes identity mid stream looks like something else. Stopping is almost always the cheaper mistake.

How each proxy type fails

Datacenter proxies fail the least often. The servers are stable, the addresses rarely change under you, and a drop is usually a hard drop you can see. Their weakness is that the address range is recognizable as hosting, which is a separate problem for a separate article.

Residential proxies route through real household connections, and that’s where continuity gets fragile. The exit is someone’s home router or device, which can go offline when that household turns something off. Providers usually offer two modes: rotating, where the exit changes per request or on an interval, and sticky, where you keep an exit for a set duration. Sticky duration varies by provider and plan, so read yours instead of trusting a default. Even a sticky session ends when the underlying peer disappears, and depending on the provider, you may be silently reassigned to another peer instead of receiving an error. That’s the exit change with a live tunnel from earlier, and it’s the classic residential failure.

Mobile proxies route through cellular connections. Carriers typically put many subscribers behind shared addresses, which is useful for blending in, but the address can change when the modem or phone reconnects. A mobile exit that’s been reset on purpose by a rotation call is a planned change. One that changed because a modem rebooted or lost signal is an unplanned one, and the client may not be told.

The practical lesson is to ask your provider three specific questions. What happens to my connection when the exit goes away: error or silent reassignment? How long does a sticky session last? Is there a way to be told when the exit changes? If the answers are vague, test it yourself and write down what you observe, without assuming.

What a mobile modem drop looks like from the operator side

Running modem farms taught me that “the proxy” is a chain with several links that can each break. There’s the modem, the SIM and carrier session, the host machine that exposes the modem as a proxy port, and the gateway or network path between that host and you. A drop can start at any of them.

Take the modem reconnecting. The cellular session ends, the modem renegotiates with the carrier, and it comes back with whatever address the carrier hands out. While that happens, the proxy port on the host either stops accepting connections, which is the clean outcome, or stays open and forwards traffic into a dead interface. In the worst configurations, a host with two network paths can route that traffic out through its other uplink instead. That last case is a real failure mode on multi-uplink hosts, and it means the exit your customer or your own browser sees can silently become the host’s regular connection.

This is why, in my own setups, rotation is an explicit action that I schedule between sessions and never something that can land in the middle of one. It’s also why I care whether a port fails closed. A port that returns an error when its modem is down is doing you a favor. A port that keeps answering is hiding the problem.

When you’re buying mobile access from someone else, you can’t see any of this. You can only test behavior: disconnect the test, observe what the exit IP does, and check whether errors appear or traffic continues. Report what you saw, not what the marketing page says.

The worst outcome: failing open

Everything so far describes the exit changing. Failing open is worse, because your own network becomes visible. It is usually caused by a configuration that tells the client what to do when the proxy is gone, and the answer is “just go direct.”

The classic example is a proxy auto-config file. A rule written as a proxy address followed by a DIRECT fallback means the browser will use the proxy when it responds and go straight out when it doesn’t. That’s a convenience feature for office networks, and it’s a leak for anyone who needs isolation. Some tools and extensions use similar fallbacks under friendlier names like “bypass if unreachable.” When you audit a setup, read the rule literally: if the return value can end in DIRECT, the file describes a leak waiting for a bad minute.

A system-level VPN without a kill switch has the same property. The tunnel drops, the operating system’s default route comes back, and every application carries on over your regular connection, often before you notice. Some apps also ignore system proxy settings entirely and connect directly, so the proxy you think covers everything covers only the browser.

There’s also the multi-tool trap. You run a browser through a local forwarding tool, which points at the real proxy. If the forwarder crashes, the browser’s connection either errors, which is fine, or the browser is configured with a second fallback, which isn’t. Every extra layer is another place for a fallback to hide.

The test is simple and cheap. Start a session, confirm the exit IP, then break the proxy on purpose, for example by blocking the port, and watch what the browser does. If any page loads, you’ve found a fail-open path. Do this once per setup, and again whenever you change tools.

How antidetect browsers tie a profile to its proxy

An antidetect browser profile bundles a fingerprint with a proxy assignment. At launch, most tools read the proxy’s exit address and derive dependent settings from it: time zone, locale hints, and often geolocation. That’s good design, because the signals agree at the start of the session.

It also creates a quiet problem. Those values are set once, at launch. If the exit changes mid session, the profile keeps reporting the original time zone and geolocation while the connection now comes from somewhere else. The mismatch is precisely the kind of inconsistency that’s easy for a platform to compute: an address in one place, a browser clock in another.

Behavior on a dead proxy differs between tools, and I’m not going to claim how any specific product behaves, because versions change. The things you should verify in your own tool are these. Does it check the proxy before launching a profile, and does it refuse to launch if the check fails? Does it keep checking during the session, or only at start? What happens to open tabs when the proxy stops responding: do they error, or does the tool offer a direct fallback? Is there a setting that disables traffic when the proxy is unreachable?

Also check how the proxy is attached. A proxy set inside the profile applies to that profile’s traffic. A proxy set at the operating system level applies to everything, including things you didn’t intend. Mixing the two produces confusing results during a failure, because part of the traffic may follow one rule and part the other. Pick one layer and know exactly what it covers.

A worked example, step by step

This is an illustrative scenario built from failure shapes I see often, not a test result. Suppose a profile runs on a mobile exit, forty minutes into a routine session on an account that’s been active for months. The proxy host’s modem loses its cellular session.

In the fail-open version, the profile’s proxy rule has a direct fallback. The modem goes down at minute forty. The browser’s requests to the proxy time out, and after the timeout it retries directly. The next page loads fine, so nothing looks wrong. The platform receives the same session token from a home broadband address in the same country, different operator, different network type, with a browser that still reports the original time zone. The modem returns a minute later with a new carrier address, and the proxy resumes. In the operator’s own view, the session had a “brief hiccup.” In the platform’s view, the account moved from a carrier network to a residential one and back, inside a minute.

In the fail-closed version, the profile can only reach the internet through its proxy, enforced by a firewall rule on the machine. The modem goes down. The browser shows errors. A health check outside the browser notices the exit is unreachable within a few seconds and pauses the profile. The platform sees requests stop. When the modem returns with a new address, the check compares the new exit’s network, country, and city against the session’s starting values. If the carrier and city still match, the operator resumes with light activity. If not, the session is ended for the day.

Look at what each version leaves behind. The fail-open operator has a browser that never raised an error and no log entry at all, so the only trace of the event sits on the platform’s side, where they can’t read it. The fail-closed operator has a timestamped record: the minute the exit went unreachable, the address that came back, and the comparison result. That record is what lets them decide calmly the next morning, and it’s what lets them notice if the same modem does this every evening.

The difference is whether anything in the stack was allowed to make a decision on your behalf. Proxy quality was the same in both.

Edge cases that catch careful people

Even with a proxy rule that doesn’t fall back, traffic can still bypass the tunnel. A few cases deserve their own checks.

WebRTC can expose addresses outside the HTTP path, because it uses UDP and peer connection mechanisms that some proxy setups don’t carry. Antidetect browsers generally include controls for this, but the control has to be set on, and it should be tested on a page that reports what WebRTC reveals, for each profile type you use.

DNS is another. If the browser resolves names locally instead of through the proxy, your resolver sees the lookups. With SOCKS5 proxies, there’s usually an option to resolve remotely. With HTTP proxies, resolution typically happens at the proxy. Know which you have.

IPv6 is a classic. A proxy that only handles IPv4 paired with a machine that has working IPv6 can leave the v6 path open. Check your exit on an address-echo page that shows both versions.

Long-lived connections behave differently from page loads. Websockets, video calls, and streaming sessions may hold a connection through the old path, then reconnect through a new one when it breaks, without any visible page reload. Background tabs keep making requests too, so a drop can be noticed by a tab you forgot was open. Service workers and scheduled syncs can fire at odd moments.

Sleep and wake deserve a mention. A laptop that sleeps mid session and wakes on a different Wi-Fi network can resume every open connection before the proxy rule or the health check has had a chance to run. If you leave profiles open overnight or between tasks, close them instead, and start fresh with a check.

Finally, retries. Some clients automatically retry failed requests, and when the failed request was a purchase, post, or message, the retry after a reconnect can duplicate the action. That’s another reason to stop the session instead of letting it self-heal.

Building a setup that fails closed

There are three layers, and you want at least two of them.

The first is the network boundary. Run the browser inside a virtual machine, container, or dedicated device whose only permitted outbound route is to the proxy host and port. A firewall rule that drops everything else means a dead proxy equals no traffic, regardless of what the browser’s settings say. This is the strongest layer because it doesn’t depend on any application behaving well.

The second is an out-of-band health check. A small script, running outside the browser, periodically requests an address-echo endpoint through the same proxy and records the result: exit IP, network operator, country, and city. It compares each result with the values captured at session start. On an error, it pauses the profile. On a changed exit, it flags the session. Choose the interval based on how costly a few unnoticed seconds are. Shorter catches more, and costs more requests through the proxy.

The third is the tool’s own configuration: no direct fallback, check the proxy before launch, refuse to start on failure, WebRTC set to follow the proxy, remote DNS where available.

For cloud phones, the logic is the same but the boundary is different. The phone’s connectivity comes from its host and modem, so a drop usually means the device loses network entirely, which is fail closed by nature. Your risk there is a host with a second uplink, so confirm the phone can only route out through its intended modem.

Write down the expected exit fingerprint per profile. A health check with nothing to compare against can only tell you the internet works.

What to do after a drop

Once it happens, sort the event into one of four outcomes using the health check’s log and the proxy provider’s status.

If nothing left the profile, meaning errors only and the same exit returned, resume after a short pause. Keep the next actions ordinary and don’t try to “make up” for the gap.

If the exit changed but stayed coherent, same country, same city, same network type, same carrier family, log it. Continue with lighter activity, or end the session at a natural stopping point. I prefer ending.

If the exit changed to a different network type or location, end the session. Don’t keep pushing to see whether it was noticed. Note the event against the account, give it a rest period, and restart on a fresh, consistent exit. I can’t tell you how long a rest is long enough, because I don’t know what a given platform does with the signal.

If any traffic went out directly, treat that profile as having touched your real network. Stop, record exactly what happened, and review whether other accounts share that connection or device. Then fix the leak before any profile runs on that setup again.

Whatever the outcome, write down what you know while it’s fresh: the time, which profile, what the health check reported, and what you did next. If an account is restricted a week later, that note is the only way to connect cause and effect, and it’s how you learn which of your setups drop most often.

If a platform asks you to verify or confirm your identity afterward, only do that on accounts that are genuinely yours, honestly and with information that’s actually true. Don’t respond to a challenge by improvising. And never let an automated retry loop hammer a login page after a drop. That adds a pattern on top of the original problem.

What the common alternatives get wrong

Rotating proxies on every request are made for scraping, not for a logged-in account. They change the exit constantly, which is the exact thing a session needs to avoid. If you use a rotating pool for account work, use its sticky mode, and verify how it fails.

“Just use a VPN” solves a different problem. A consumer VPN puts many users on shared addresses, often recognized as VPN ranges, and without a kill switch it leaks on drop. It’s also a single exit for every profile, which ties your accounts together at the network level.

Trusting an uptime figure misreads the metric. A provider can be up ninety-nine percent of the time and still reassign your exit several times a day. Uptime measures whether the service answers, not whether your identity stays continuous. Ask about exit stability instead.

Auto-reconnect features sound helpful, but when the reconnect lands on a different exit and the tool hides it, they remove the one signal you needed. Prefer tools that stop and tell you.

Putting many profiles behind one proxy makes a drop a fleet-wide event: every profile changes at the same second, which is itself a correlation. Spreading profiles across separate exits limits the blast radius.

Finally, retry scripts. A script that reconnects and replays the last action turns a network hiccup into duplicate activity. Make your automation halt on error and wait for a human or a health check.

Your Monday checklist

Start with a one-time audit of each setup you run, then a few small habits.

  1. Find every place a fallback could hide: PAC files, extension settings, the tool’s own “if unreachable” option, and any forwarding software between the browser and the proxy.
  2. Break the proxy on purpose, for each setup, and confirm no page loads. Write down the result and the date.
  3. Add a network boundary: a firewall rule, VM, or container that only allows traffic to the proxy host and port.
  4. Test WebRTC, DNS, and IPv6 on an echo page for each profile type, with the proxy working, and record what each reports.
  5. Ask each provider what happens when an exit disappears, how long a sticky session lasts, and whether you can be notified of changes. Keep the answers you actually get, including “we don’t know.”
  6. Capture an expected exit fingerprint per profile: network operator, country, city, network type.
  7. Run an out-of-band health check that compares against that fingerprint and pauses the profile on any mismatch.
  8. Stop scheduling rotations inside active sessions. Rotate between sessions only.
  9. Give each profile its own exit where you can, so one failure doesn’t touch everything.
  10. Write a one-page response rule using the four outcomes above, so the decision after a drop is already made before it happens.

None of this makes a platform’s decisions predictable, and none of it promises an outcome. It removes avoidable mistakes, and it gives you a record to reason from when something does go wrong.

If you want more breakdowns of how antidetect browsers, proxies, and cloud phones behave when things go wrong, the rest of the library is on the Multi Account Ops home page.

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

need infra for this today?