← back to blog

Shared Neighbours In A Residential Proxy Pool: What IP Overlap Actually Means

What “shared neighbours” means in a residential pool

Every residential proxy provider sells you access to a pool of IP addresses that real internet service providers assigned to real homes. The pool is shared by definition. You are never the only customer using it, and depending on the provider you are frequently not the only customer using the exact IP you were just handed.

“Shared neighbours” is the term I use for a specific failure mode inside that shared pool: two of your own accounts, or your account and someone else’s account, land on the same IP address, the same subnet, or the same carrier-level NAT block within a window short enough that a platform’s fraud system notices. It is not about the provider getting hacked or leaking data. It is a structural consequence of how residential pools are built and sold, and it is one of the more common reasons multi-accounting setups get linked even when every other part of the fingerprint looks clean.

This matters more than people expect because the instinct when an account gets flagged is to blame the browser fingerprint, the canvas hash, the WebGL string, or the anti-detect tool. Sometimes that is the actual cause. But I have pulled connection logs on farms I run where the browser profile was airtight and the only shared signal between two flagged accounts was the exit IP, reused inside a window measured in minutes. The fingerprint layer gets all the attention because it is visible and testable in a browser. The proxy layer is quieter, and overlap inside it is much harder to see from the customer side.

The rest of this piece walks through where overlap comes from, why a big advertised pool size does not prevent it, how platforms actually detect it, and what to check before you commit budget to a provider.

Where residential IPs actually come from

Residential proxy pools are built from real consumer devices, almost always through an SDK embedded in a free app, a VPN, or a browser extension that a person installed on their own phone or laptop. When that device is idle and connected, the provider can route a customer’s traffic through it, using the household’s real ISP-assigned IP as the exit point. Some providers run this on a genuine opt-in basis with disclosure; a meaningful share of the industry’s supply history involves apps that buried the consent inside terms nobody read. That history is worth knowing when you evaluate a provider’s claims about their sourcing, but it’s a separate issue from overlap.

A single provider does not own these IPs. They rent access to a rotating population of devices that come online and go offline on their own schedule, tied to whether that person’s phone is charging, connected to Wi-Fi, and running the SDK in the background. This is why residential pools are described in terms like “70 million IPs” rather than a fixed inventory: the number is a rolling estimate, not a static list you can audit.

That rolling nature is also where overlap starts. The provider is drawing exit points from a population that is smaller at any given instant than the headline number suggests, and multiple customers are drawing from the same population at the same time. You are sharing a pool with every other customer that provider has.

How overlap happens even when the pool is huge

A provider advertising tens of millions of IPs is describing a historical or rolling total, not concurrent availability. At any given moment, the number of devices actually online, idle, and geographically matching what a customer asked for is a small fraction of that figure. If you request an exit IP in a specific city, for a specific carrier, the addressable set shrinks fast, sometimes to a few hundred or a few thousand live devices.

Rotation makes this worse in a subtle way. Every time a session ends and a new IP gets assigned, the provider is picking from that same shrunk, geo-filtered set. Run a hundred sessions in an afternoon targeting the same city and you are not drawing from tens of millions of IPs, you are drawing repeatedly from the same few thousand, with replacement. Basic probability says you will hit repeats, and you will hit them faster than the headline pool size implies.

Now add other customers into the same math. The provider is not reserving that city’s pool for you. Every other customer targeting the same city, the same carrier, or the same country during the same window is drawing from an overlapping set. Two completely unrelated customers, running completely unrelated operations, can and do land on the same residential IP within the same hour, sometimes the same minute, purely because the provider’s live inventory for that geo is a lot thinner than the sales page suggests.

Pool size printed on a pricing page tells you almost nothing about concurrent overlap risk for the specific geo and carrier combination you actually use. It is a vanity metric unless the provider can also tell you how many devices are live, right now, in the slice you care about, and almost none publish that.

What platforms see when two of your accounts share a neighbour

Platforms doing fraud and multi-accounting detection do not need to see your browser fingerprint to notice IP overlap. IP-level signals arrive before a single line of JavaScript executes, and they get scored independently of whatever the browser reports.

The basic signal is exact IP reuse: account A logs in from 203.0.113.45, and forty minutes later account B logs in from the same address. That alone is a strong linking signal on most platforms, especially ones built around consumer behavior where a residential household genuinely running two of your unrelated accounts in the same session is statistically odd.

The signal gets stronger, not weaker, when the platform adds timing. A short gap between two “different people” using the same home IP looks nothing like two actual housemates who happen to use the same service, which typically shows spaced-out, asynchronous usage over days. A tight cluster of new-account signups or logins from one IP inside a short window is the shape fraud models are specifically built to catch, because it matches automated or coordinated activity far better than it matches coincidence.

Beyond exact match, platforms score at the subnet and ASN level too, which I cover in more depth further down. The short version: even if your two accounts never touch the literal same address, landing in the same /24 block or the same carrier’s NAT range close together still raises a correlation score, just a weaker one than an exact match. It is entirely a property of where your traffic exited to the internet, and it is invisible from inside the browser you are testing in.

A worked example: two accounts, one exit IP, forty minutes apart

Here is the mechanic laid out concretely, without naming a specific platform, since the shape is generic across most consumer platforms with fraud scoring.

Say a residential proxy pool has roughly 4,000 live devices in a target city at a given hour, filtered to the carrier you requested. You run a session for account A that gets assigned IP X. The session ends after fifteen minutes and the IP is released back to the pool. You start a session for account B twenty five minutes later. The provider’s rotation logic picks an IP for account B from that same live pool of roughly 4,000. The odds of picking IP X specifically look low on paper, maybe one in four thousand for a single draw. But that is not the number that matters if you are running many sessions across many accounts across a day, because you are making that draw repeatedly, and every account you run is drawing from the same shrunk set.

Run 40 sessions in a day against a 4,000-device pool and, by the birthday-paradox style math that governs collision problems, the chance that at least two of those sessions share an IP climbs a lot faster than intuition suggests, easily into double-digit percentages depending on how the pool is filtered and how fast devices churn. This is not a hypothetical edge case, it is the ordinary outcome of running volume against a pool that is smaller, live, than it is on paper.

When that collision happens, the platform does not know it was a probability accident. It sees two of your accounts on the same residential IP within an hour, and it scores that exactly like it would score two accounts you deliberately tried to link. The intent behind the collision is invisible to the detection system; only the pattern is visible.

Subnet and ASN overlap: the problem that hides pool size

Exact IP reuse is the easy case to reason about. Subnet and ASN-level overlap is the harder, quieter version, and where a lot of “how did they catch this” confusion comes from.

An ASN, autonomous system number, identifies which network operator owns a block of IP space, typically an ISP. A /24 subnet is a block of 256 consecutive addresses usually assigned to the same regional pocket of that ISP’s infrastructure. Platforms with mature fraud stacks check for more than exact IP matches: they look for a cluster of accounts from the same /24 or ASN behaving in a correlated way, which catches patterns that exact-match checking misses.

This matters for residential pools specifically because a provider’s live device inventory in a given city is often concentrated inside a handful of local ISP infrastructure blocks. Even when rotation gives you a different literal IP every session, those IPs are frequently drawn from the same small set of subnets, because that is where the ISP’s residential customers actually are. Two accounts that never share an exact IP can still share a /24, and a fraud model watching subnet-level velocity will flag that correlation.

The practical effect is that “my two accounts never used the same IP” is not the same claim as “my two accounts were network-isolated from each other.” You can pass the naive exact-match check and still fail a subnet-level correlation check, and from the outside, with no visibility into the platform’s model, that looks like an unexplained ban. It is just operating at a layer of the network stack invisible from a browser’s network tab. If you are diagnosing a pattern of flags across accounts that used different proxies, checking whether those proxies shared an ASN or subnet is a more productive first step than re-testing the browser fingerprint again.

Sticky sessions raise the collision odds

Most residential proxy providers offer a choice between rotating sessions, where the exit IP changes on a fixed interval or every request, and sticky sessions, where you hold the same exit IP for an extended window, often 10 to 30 minutes, sometimes longer on request.

Sticky sessions exist for a good reason: a lot of platforms treat mid-session IP changes as suspicious on their own, since a real residential connection does not usually hop addresses in the middle of a single browsing session. So for legitimate account management workflows, holding one IP per session is the more natural-looking pattern, and it is the setting most anti-detect browser guides recommend pairing with a profile.

But sticky sessions change the collision math in a way that is easy to overlook. A rotating session that lasts fifteen seconds occupies one slot in the live pool briefly, then frees it; a sticky session that holds an IP for 30 minutes occupies that slot the whole time. Any other customer requesting the same geo and carrier during that half hour cannot draw that exact address, but they can still land on a different address in the same subnet, and the pool’s overall churn slows because more addresses are locked up in long sessions at once.

The net effect on a busy pool is that sticky sessions reduce exact-IP collisions somewhat, because addresses are held longer and reused less often per unit time, but they do not reduce subnet-level correlation, and they extend the window during which two accounts on the same or nearby addresses are active simultaneously. There is no free setting here. Rotating sessions and sticky sessions each trade one kind of overlap risk for a different one, and the right choice depends on what the specific platform’s fraud model actually weighs, which you will not know for certain without testing.

Anti-detect browsers do not touch this layer

This is worth being blunt about: a lot of marketing around anti-detect browsers quietly overpromises here. Tools like Multilogin, GoLogin, Kameleo, AdsPower, and Dolphin Anty operate at the browser fingerprint layer. They control what JavaScript-readable signals a site sees: canvas output, WebGL renderer strings, font lists, screen resolution, timezone, navigator properties, audio context fingerprints, and the consistency between all of those and the user agent string. That is a real and useful layer to control, and getting it wrong is a common, avoidable mistake.

None of these tools touch the proxy layer. They let you attach a proxy to a profile, and a good one will warn you about mismatches between your proxy’s geolocation and your profile’s timezone or locale settings, which is a genuinely useful check. But the IP itself, whether it is currently shared with another customer, whether it collides with your own other accounts, whether it sits in a subnet a platform has already flagged, is entirely determined by your proxy provider and your session settings, not by the anti-detect browser.

No anti-detect browser makes an account undetectable, unbannable, or risk-free, and a clean fingerprint profile running on a proxy IP that collides with your other accounts will still get correlated at the network layer regardless of how well the browser layer is configured. I have tested profiles that were fingerprint-perfect by every check a browser-side tool offers and still got flagged, because the flag came from the IP, not the canvas hash. Treating the anti-detect browser as the whole solution, rather than one layer of several, is the single most common gap I see in setups that get linked despite “doing everything right” on the fingerprint side.

What I check when I test a proxy pool against these browsers

When I bring a new residential proxy provider onto a farm, the browser fingerprint test is the easy, fast part, and it is not where I spend most of my time. What takes longer, and what actually tells me whether the pool is going to cause linking problems, is checking behavior at the IP layer over a realistic volume of sessions, not a handful.

Concretely, that means pulling a batch of exit IPs across a day’s worth of sessions targeted at the geo and carrier mix I actually plan to use, and checking for exact repeats across the volume I would run in production, not a small sample. It means checking what ASN and subnet each assigned IP falls into, and whether that set of subnets is narrow or genuinely broad for the city being targeted, since a narrow set is the leading indicator of the collision math from earlier getting worse than the provider’s marketing implies. It means testing both rotating and sticky session settings under the same load to see how the overlap profile changes between them, since I have seen providers where one setting is noticeably worse than the other for a given geo.

None of that is a browser-fingerprint test; it happens by logging the proxy’s own connection metadata across a batch of sessions and analyzing it separately, not inside Multilogin, GoLogin, or any of the other tools. The browser layer gets tested too, for the usual canvas, WebGL, and timezone consistency checks, but that test passing tells you nothing about whether the pool underneath it is thin enough to cause collisions at the volume you actually intend to run.

Pool size on the label vs pool size in practice

Pricing pages love a headline number. “50 million residential IPs” reads as an unambiguous quality signal, and providers know it moves buyers. The problem is that the number describes a rolling historical count of devices the provider has ever routed traffic through, not a live, concurrent, geo-filtered inventory, and there is no standard way for a buyer to verify it independently.

The number you actually need, and the number providers almost never publish because it is unflattering and hard to measure honestly, is concurrent live devices in the specific city and carrier combination you plan to use, at the time of day you plan to use it. That number can be two or three orders of magnitude smaller than the headline figure, and it is the number that actually governs your collision risk.

There is no reliable shortcut to estimating this from the outside. The most honest approximation I have found is empirical: run a meaningful batch of sessions against the specific geo and carrier target you care about, log every assigned IP, and count repeats. If you see exact-IP repeats inside a batch of a few hundred sessions targeting one city, that is a direct signal the live pool for that slice is thin, regardless of what the pricing page claims globally. A provider that looks enormous in aggregate can still be thin in the one geo you actually need, because their device population isn’t evenly distributed; it clusters wherever their SDK partners have the most installs, not where your use case needs it.

Treat the advertised pool size as a marketing figure, not an engineering spec, and verify the number that matters with your own logs before committing meaningful budget or volume to a provider.

Residential vs mobile vs datacenter: different overlap math

The three common proxy types have genuinely different overlap profiles, and conflating them leads to bad assumptions.

Datacenter proxies are the easiest to reason about, and the easiest for platforms to flag outright. The IP ranges belong to known hosting providers, are usually static or semi-static, and are not shared with unrelated retail customers because there is no “household” behind them. Overlap risk with your own other accounts is entirely a function of your own provider’s allocation and your own reuse pattern, and platforms with any fraud maturity often block whole datacenter ASN ranges regardless of overlap, since a residential-looking service rarely expects real users to arrive from a hosting company’s network.

Residential proxies have overlap risk driven by live device population size in your target geo, which fluctuates by time of day and provider SDK penetration in that region, and which you cannot see directly, only estimate from your own session logs.

Mobile proxies add a structurally different kind of sharing that has nothing to do with how many customers the provider has. Mobile carriers route large numbers of real subscriber devices through a small number of public IP addresses using carrier-grade NAT, which means many genuine, unrelated phone users share one exit IP simultaneously as an ordinary feature of how mobile networks work, not as a proxy provider artifact at all. This changes the detection math in your favor for some platforms, because they are used to seeing shared mobile IPs and score them more leniently than a residential IP showing the same pattern. But it does not eliminate overlap risk with your own accounts; it just changes the baseline the platform is comparing you against. The next section covers this in more depth because it is the case people most often misunderstand.

Mobile CGNAT: shared neighbours by design, not by accident

Carrier-grade NAT, CGNAT, is the mechanism mobile carriers use to conserve IPv4 addresses. Instead of assigning each subscriber a unique public IP, the carrier assigns thousands of subscribers to a shared pool of public addresses, translating traffic at the carrier’s edge. This is standard practice across essentially every mobile carrier worldwide, unrelated to proxy services.

The consequence for anyone using mobile proxies is that “shared neighbours” on a mobile IP is not an occasional collision, it is the constant, structural, expected state. At any moment, a given mobile exit IP might be carrying traffic from dozens or hundreds of genuine subscriber devices doing unrelated things, completely independent of your proxy provider. Platforms that see meaningful mobile traffic volume generally know this and score shared mobile IPs against a different baseline than a residential IP showing the same pattern.

This is genuinely useful context, but it is not a loophole. The lenient baseline applies to the ordinary background sharing that CGNAT causes among real subscribers. It does not extend to a pattern where your own accounts cluster together in ways that stand out against that noisy baseline, for example, if your sessions on a mobile IP always arrive in the same tight time windows, always carry the same downstream fingerprint quirks, or always touch the same set of target accounts in a correlated sequence. Fraud systems that are mature enough to know about CGNAT are also generally mature enough to look past the raw IP-sharing signal and score the behavioral pattern underneath it. Mobile proxies change the noise floor you are hiding in, they do not change whether a correlated pattern stands out above that floor.

What actually increases your collision risk

A few concrete factors move your real-world collision risk, worth checking in this order because they are roughly ordered by how much control you have over them.

Geo and carrier specificity is the biggest lever. The more narrowly you target a proxy request, down to a specific city and a specific mobile carrier, the smaller the live device pool you are drawing from, and the higher your collision odds against your own other accounts. Broader geo targeting, a whole country rather than one city, trades precision for a much larger live pool and correspondingly lower collision risk, if your use case can tolerate the broader targeting.

Session volume relative to pool size is the second lever, and it is the one people underestimate because headline pool numbers make volume feel safe. Forty sessions against a thin 4,000-device local pool behaves nothing like forty sessions against a broad national pool, even if both come from a provider advertising the same tens-of-millions headline figure.

Provider diversity matters more than most buyers assume. Different residential providers draw from overlapping but not identical SDK partner networks, and running all your volume through a single provider concentrates your risk inside whatever that one provider’s live inventory actually looks like in your target geo. Spreading volume across two or three providers with genuinely different sourcing reduces the chance that a thin pool on one provider becomes your single point of collision failure, though it adds operational complexity in managing multiple accounts and billing relationships.

Session type, sticky versus rotating, is the fourth lever, covered earlier, and it is a trade-off rather than a fix. Timing clustering is the fifth: spacing your sessions out, rather than running a batch in a tight window, reduces the chance that a collision, if it happens, also looks like a correlated burst to a timing-aware fraud model. None of these eliminate collision risk. They each move the needle, and stacking the ones that fit your actual use case is the realistic goal.

What to check before you buy, and what to do Monday

If you are evaluating a residential proxy provider, or auditing one you already use, here is where the actual signal is, concretely, without relying on the pricing page.

Ask the provider directly for live concurrent device counts in your specific target geo and carrier, not the global headline number. A provider confident in their coverage for your use case will usually give you a real answer or let you test it; one that deflects to the global figure is telling you their coverage is thin where you need it.

Run your own collision test before committing budget. Pull a batch of sessions at the volume and cadence you actually plan to use, log every assigned IP, ASN, and subnet, and count exact and subnet-level repeats. This is the single most direct way to validate a provider’s real-world overlap risk for your specific use case.

If you are running multiple accounts that need to stay uncorrelated, treat the proxy layer and the browser fingerprint layer as two separate problems that both need solving, not one problem the anti-detect browser solves on its own. A tool like Multilogin, GoLogin, Kameleo, AdsPower, or Dolphin Anty gives you consistent, isolated fingerprint profiles, but it has no visibility into whether the IP attached to that profile is currently shared with your other accounts or clustered in a subnet a platform already distrusts. Pair fingerprint isolation with your own proxy overlap testing, choose geo and carrier targeting no narrower than your use case actually requires, and reconsider provider concentration if you are running enough volume that a single thin pool becomes a realistic single point of failure.

None of this makes an account unbannable, and no configuration removes risk entirely on a pool you are structurally sharing with strangers. What it does is close the gap between what you think you tested, the browser fingerprint, and what actually got two accounts linked, the IP underneath it, which is where I have most often found the real answer when a setup that looked clean on every browser-side check still got flagged.

If you want to see this kind of testing done on camera against real providers and real anti-detect browsers, rather than taking a pricing page’s word for it, that is what we cover on Anti-Detect Review.

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

need infra for this today?