Residential Proxies: Real IPs in 170+ Countries
Residential proxies route your traffic through real consumer connections, so requests look like ordinary household users rather than a datacenter. That is what makes them work on sites that reject datacenter IP ranges outright: retail, travel, social, and anything behind serious bot protection.
What actually happens when you send a request
Your client connects to gw-residential.node4.io and authenticates with your username and password. The gateway parses the targeting segments out of the username, checks each one against your plan's entitlements, and selects an exit in the partner network that matches: a household connection in the country, state or city you asked for. Your request then leaves from that consumer address and the response returns along the same path. For HTTPS, the gateway carries an opaque CONNECT tunnel, so the TLS session runs end to end between your client and the destination; we relay encrypted bytes, we do not terminate them. From the target's point of view the visitor is the household connection: its IP, its ISP, its geography.
Targeting down to the city
Targeting rides in the username, so you can change country per request without touching your dashboard or rotating credentials. Every segment is validated against your plan before the connection is made. An entitlement you do not have is refused with a clear reason rather than silently downgraded, because being served the wrong country without knowing is worse than an error.
- user-42-abc123-country-us: anywhere in the United States
- user-42-abc123-country-au-state-nsw-city-maitland: one city
- user-42-abc123-session-482913: hold one exit IP across requests
Sticky sessions, described honestly
A sticky session holds the same exit IP across repeated requests. The hold is best effort rather than a fixed window: exits are real consumer connections, so the partner network decides how long a pin survives, and a session's address can change when the peer behind it goes offline. Design multi-step flows to tolerate an address change rather than assuming one address forever. A session ID is any string of letters and digits, up to 32 characters, that you choose: send the same ID to stay on the same exit, change it to move to a fresh one. Session identifiers are hashed per customer before they reach the upstream network, so nobody can steer onto your exit by guessing your session ID. What hashing cannot do is reserve an address: the partner network's session space is finite, so under heavy concurrent use two sessions can land on the same exit. A sticky exit is yours for the session, not exclusive to you. The dashboard builder generates an ID for you.
Where the IPs come from
Residential is a partner network, not IPs node4 owns, and we would rather say so than imply otherwise. Before we put it on sale we spot-checked 30 exits on 27 July 2026: all 30 carried traffic, and none of them came from a hosting range. That is a sample of 30, not a survey of the pool. The per-country and per-city figures on this page are a different kind of number: they are read from the live coverage snapshot and refreshed daily. Datacenter, shared and rotating products run on IP blocks node4 does own.
What residential proxies are the wrong tool for
Per-gigabyte billing and consumer last-mile connections shape what this product is bad at, and it is worth knowing before you buy. Bulk transfer of large files is the clearest case: if the job is moving gigabytes rather than making many small requests, a per-GB price punishes exactly the thing you are doing, and an unlimited-bandwidth datacenter proxy does the same work for a flat monthly cost. Latency-sensitive work is another: a household connection is inherently more variable than a datacenter uplink, and no amount of targeting changes that. And if your target accepts hosting ranges (most APIs and a large share of ordinary websites do), you are paying the residential premium for a property you do not need. Try the rotating or datacenter product first and move here only when the target actually forces it.
When an exit stops working
Residential exits are real devices on real networks, so churn is normal: peers go offline, and destination sites sometimes decide they dislike a particular address. The handling differs by mode. In default rotation the problem solves itself: the next request is assigned a different exit, so a transient failure is worth one retry before it is worth an investigation. In a sticky session, a dropped peer means a new address, so the target may observe an IP change mid-flow; design multi-step flows to tolerate that rather than assuming one address forever. If a target has soured on your current sticky exit, do not fight it: switch to a fresh session ID and you get a fresh exit. What no residential product can honestly promise is an exit that never gets challenged. The value is that recovering from a challenge costs you one username change instead of an infrastructure change.
Keeping per-gigabyte costs under control
Bandwidth is metered on bytes transferred in both directions, which makes efficiency a line item rather than a virtue. The biggest single saving in scraping workloads is not fetching what you do not parse: a product page's HTML is often a small fraction of its images, fonts and scripts, so a client that requests only the document, or hits the underlying data endpoint directly, cuts consumption dramatically. Retries deserve attention too, because a failed request that transferred a response body still transferred bytes; back off rather than hammering, and abandon responses you can already tell are useless from the status line. The dashboard's usage page shows consumption as it accrues, so measure the cost of one unit of your workload early and multiply, rather than discovering the run rate at the end of the month.
Protocols and authentication
HTTP(S) and SOCKS5 both work with the same credential: the gateway identifies you by username, not by protocol, so there is no second credential to manage. Authenticate with username and password. Bandwidth is metered per gigabyte with no monthly commitment.
How to evaluate the pool before committing
Because there is no monthly commitment, the sensible evaluation is a small live one rather than a feature-list comparison. Buy the smallest bandwidth tier, point the code samples below at your real target (not just an IP-echo service) and check three things: that the geography you need actually resolves (the dashboard builder only offers locations with live exits, so build the username there), that your target accepts the traffic at the request rate you intend, and that the gigabytes consumed per unit of useful work support your economics. We audited the pool before selling against it, but your target is the judge that matters, and testing against it costs a few gigabytes at most.
Pricing
Residential
High-quality residential IPs for accurate, location-specific data
| Bandwidth | Price per GB | Total | Discount |
|---|---|---|---|
| 3 GB | $2.49/GB | $7.47 /mo | - |
| 5 GB | $2.29/GB | $11.45 /mo | Save 8% |
| 10 GB | $1.99/GB | $19.90 /mo | Save 20% |
| 25 GB | $1.69/GB | $42.25 /mo | Save 32% |
| 50 GB | $1.39/GB | $69.50 /mo | Save 44% |
| 100 GBPopular | $1.09/GB | $109.00 /mo | Save 56% |
| 250 GB | $0.89/GB | $222.50 /mo | Save 64% |
| 500 GB | $0.75/GB | $375.00 /mo | Save 70% |
| 1 TB | $0.65/GB | $650.00 /mo | Save 74% |
| 5 TB | $0.49/GB | $2,450.00 /mo | Save 80% |
- Bandwidth
- Per GB pricing
- Threads
- Unlimited
- Protocols
- HTTP(S) / SOCKS5
Connection details
One hostname for every country. Targeting is chosen in the username, so you never switch endpoints or rotate credentials to change market.
Code examples
# Anywhere
curl -x http://USER:PASS@gw-residential.node4.io:8082 https://api.ipify.org
# United States
curl -x http://USER-country-us:PASS@gw-residential.node4.io:8082 https://api.ipify.org
# One city, over SOCKS5 (same credential)
curl --socks5-hostname \
USER-country-au-state-nsw-city-maitland:PASS@gw-residential.node4.io:1082 \
https://api.ipify.orgpip install requests[socks]import requests
USER, PASS = "user-42-abc123", "your-password"
HOST = "gw-residential.node4.io"
# Country-targeted
proxies = {
"http": f"http://{USER}-country-de:{PASS}@{HOST}:8082",
"https": f"http://{USER}-country-de:{PASS}@{HOST}:8082",
}
print(requests.get("https://api.ipify.org", proxies=proxies, timeout=30).text)
# Sticky session: the same exit IP across requests.
# The session id is yours to pick: letters and digits, up to 32 chars.
# Reuse it to hold the exit; change it to move to a fresh one.
sticky = {
"https": f"http://{USER}-country-us-session-482913:{PASS}@{HOST}:8082",
}
with requests.Session() as s:
for _ in range(3):
print(s.get("https://api.ipify.org", proxies=sticky).text)npm install https-proxy-agentimport { HttpsProxyAgent } from "https-proxy-agent";
const USER = "user-42-abc123";
const PASS = "your-password";
const agent = new HttpsProxyAgent(
`http://${USER}-country-gb:${PASS}@gw-residential.node4.io:8082`
);
const res = await fetch("https://api.ipify.org", { agent });
console.log(await res.text());# Rotate country per request by changing the username - no endpoint
# changes and no credential juggling.
def start_requests(self):
for country in ("us", "gb", "de", "br"):
yield scrapy.Request(
"https://api.ipify.org",
meta={
"proxy": (
f"http://user-42-abc123-country-{country}"
":PASS@gw-residential.node4.io:8082"
)
},
dont_filter=True,
)How it compares
| Feature | This page | Datacenter | Rotating |
|---|---|---|---|
| IP origin | Real consumer connections | IP blocks we own | IP blocks we own |
| Blends in as normal traffic | Best | Identifiable as hosting | Identifiable as hosting |
| Billing | Per GB | Per proxy / month | Per GB |
| Bandwidth | Metered | Unlimited | Metered |
| Geo targeting | Country, state, city | Location of the block | Country |
| Sticky sessions | Yes, session id in the username | IP is already fixed | Yes |
| Entry price | $2.49/GB at 3 GB, $0.49 at 5 TB | $1.49/proxy at 5, $0.75 at 1,000 | $0.59/GB at 10 GB, $0.29 at 1 TB |
| Best for | Targets that block hosting ranges | Sustained high volume | Bursty work needing rotation |
What people use these for
Price and availability monitoring
Retail and travel sites serve different inventory and pricing by location, and block hosting ranges outright. City-level targeting returns the page a local shopper actually sees.
Ad verification
Confirm campaigns render in the markets you paid for, from addresses that look like the audience rather than a datacenter.
SERP and local-pack tracking
Search results vary by city, not just country. Targeting a city gives you the ranking a user there sees rather than a national average.
Brand and marketplace protection
Surface counterfeit listings and unauthorised sellers that are geofenced away from head-office IP ranges.
Frequently asked questions
How is a residential proxy different from a datacenter proxy?
A datacenter proxy comes from a hosting provider's IP range, which is fast and cheap but identifiable; many sites block those ranges wholesale. A residential proxy uses a real consumer connection, so it is far harder to distinguish from an ordinary visitor, at the cost of higher price per gigabyte and more variable latency.
Do you support city-level targeting?
Yes. Coverage spans 170+ countries, and the dashboard builder only offers combinations that actually have exits, so you cannot construct a target that fails. Coverage is genuinely uneven: New South Wales has exits in Maitland but not Newcastle, which is exactly why the builder is data-driven rather than a free-text box.
Is bandwidth metered on failed requests?
Bandwidth is metered on bytes actually transferred in both directions. A refused connection transfers nothing and is not billed.
Can I use SOCKS5?
Yes, on the same credential as HTTP(S). Residential SOCKS5 supports the full targeting vocabulary (country, state, city and sticky sessions). With a session ID, both protocols resolve to the same session, so an exit pinned over HTTP stays pinned over SOCKS5. Without one, each path rotates on every request, so the two will not match: that is rotation working, not a mismatch to debug.
What happens if I exceed my plan's bandwidth?
Connections are refused rather than silently billed as overage. You can add bandwidth from the dashboard at any time.
Why does city-level coverage vary so much between places?
Because the pool is real consumer connections, its shape mirrors where people actually run peers; it cannot be provisioned into existence the way a datacenter range can. Coverage therefore concentrates where population and participation concentrate, and two nearby cities can differ sharply. Rather than publish a static city list that would drift, the dashboard builder reads the live coverage snapshot and only offers combinations that currently resolve, so the way to answer 'do you cover my city' is to open the builder and look.
Can I authenticate by whitelisting my IP instead of using a password?
Yes, with one trade-off worth understanding first. Targeting, sessions and entitlement checks all ride in the username, so the credential is not just authentication; it is how you tell the gateway what you want on every connection. A whitelisted residential connection carries no username, which means no country, city or session targeting: you get an untargeted exit that rotates freely across the pool. So whitelist residential when you want any clean address without credentials in your config, and authenticate with the username whenever the request has to land somewhere specific. Whitelisting is offered on every product; on the rotating gateways you also get a halfway option, where sending the username with an empty password keeps the targeting while leaving the secret out of your config.
What should I do when a website blocks the exit IP I am using?
In rotating mode, nothing you need to act on: the next request leaves from a different exit. In a sticky session, change the session ID and you are on a fresh exit immediately. What you should not expect, from us or anyone, is exits that never get challenged; anti-bot systems score behavior as well as IP type, so pace your requests and treat a challenge as feedback, not a defect.
Are residential proxies faster or slower than datacenter proxies?
Slower and more variable, as a class. Your traffic traverses a real household connection with whatever last mile it has, where a datacenter proxy answers from a machine on a datacenter uplink. We publish no latency figure because it varies by exit, geography and route. But if consistent response times matter more than blending in, and your target tolerates hosting ranges, the datacenter products are the better fit and cost less.
How is this different from your rotating product? Both rotate.
The mechanism is the same one-endpoint, rotation-behind-it design; the pool is the difference. Rotating draws from datacenter blocks node4 owns: cheaper per gigabyte, faster, but identifiable as hosting ranges. Residential draws from the partner network of consumer connections, which is what survives on targets that reject hosting outright. If you are unsure which you need, test the rotating product first; it is the cheaper mistake.
Guides for Residential Proxies
Setup, targeting and troubleshooting, written for people already running this in production.
- Country, state and city targeting syntax
- Proving an exit is where the menu says it is
- When to hold a sticky session instead of rotating
- Why a target blocks an IP, and what to change
- Price monitoring from real consumer connections
- Ad verification that sees what a local shopper sees
- SEO rank tracking without your own footprint
- Datacenter or residential: deciding on evidence
- Pilot-testing a residential proxy before you commit
- Driving Puppeteer and Playwright through a proxy
- SOCKS5 setup, end to end
- How authentication works on every product here
- What happens when the gigabytes run out