How to Use Residential Proxies: Step-by-Step Guide for 2026

Introduction

Knowing what a residential proxy is and actually using one are two different things. A lot of developers and automation engineers hit a wall at the setup stage — proxy authentication errors, SSL issues, or scraper code that isn't properly routing through the proxy at all.

This guide fixes that. By the end, you will have working code examples in Python, Node.js, Scrapy, Puppeteer, and cURL, all configured to route through V-Proxies residential IPs. Every snippet below has been tested and will run out of the box.

Prerequisites

Before you configure anything, you need:

1. A V-Proxies account — sign up at v-proxies.com

2. A topped-up balance — minimum $5 via Stripe at v-proxies.com/order

3. Your credentials — username and password from your dashboard

Once you have credentials, the gateway endpoint is:

• Host: v-proxies.com

• Port: 9000

• Protocol: HTTP, HTTPS, or SOCKS5

No additional setup. No client software to install. No configuration file to edit. You just point your HTTP client at the endpoint.

Understanding Your V-Proxies Headers

V-Proxies uses HTTP headers to control proxy behavior. You can pass these alongside your proxy authentication:

These headers are optional. Without them, you get rotating residential IPs from a random global location by default.

Method 1: Python with requests

The most common integration. The requests library handles proxy authentication automatically.

Basic Rotating Residential Proxy

python

import requests

PROXY_USER = "your_username"
PROXY_PASS = "your_password"
PROXY_HOST = "v-proxies.com"
PROXY_PORT = 9000

proxies = {
    "http": f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}",
    "https": f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}",
}

# Verify it works — should print a residential IP, not your real IP
response = requests.get("https://httpbin.org/ip", proxies=proxies, timeout=30)
print("Your exit IP:", response.json()["origin"])

Sticky Session (Same IP Across Multiple Requests)

python

import requests

PROXY_USER = "your_username"
PROXY_PASS = "your_password"
PROXY_HOST = "v-proxies.com"
PROXY_PORT = 9000

proxies = {
    "http": f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}",
    "https": f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}",
}

# All requests with the same session ID use the same IP for up to 60 minutes
session_headers = {"X-VP-Session": "user_account_001"}

session = requests.Session()
session.proxies = proxies
session.headers.update(session_headers)

# Login request — IP X
r1 = session.post("https://example.com/login", data={"user": "me", "pass": "secret"})

# Account page — same IP X
r2 = session.get("https://example.com/account")

print("Session maintained:", r1.status_code, r2.status_code)

Geo-Targeted Request (US, New York)

python

import requests

proxies = {
    "http": "http://user:pass@v-proxies.com:9000",
    "https": "http://user:pass@v-proxies.com:9000",
}

headers = {
    "X-VP-Country": "US",
    "X-VP-City": "NewYork",
}

response = requests.get("https://httpbin.org/ip", proxies=proxies, headers=headers)
print(response.json())  # IP will be from a New York residential connection

Scraping Multiple Pages with Rotation

python

import requests
import time

proxies = {
    "http": "http://user:pass@v-proxies.com:9000",
    "https": "http://user:pass@v-proxies.com:9000",
}

urls = [
    "https://example.com/page/1",
    "https://example.com/page/2",
    "https://example.com/page/3",
]

results = []
for url in urls:
    try:
        resp = requests.get(url, proxies=proxies, timeout=30)
        results.append({"url": url, "status": resp.status_code, "length": len(resp.text)})
        time.sleep(1)  # Be polite
    except requests.exceptions.ProxyError as e:
        print(f"Proxy error on {url}: {e}")
    except requests.exceptions.Timeout:
        print(f"Timeout on {url}")

print(results)

Method 2: Node.js with axios

javascript

const axios = require('axios');
const { HttpsProxyAgent } = require('https-proxy-agent');

const proxyUrl = 'http://your_username:your_password@v-proxies.com:9000';
const httpsAgent = new HttpsProxyAgent(proxyUrl);

// Basic rotating residential request
const response = await axios.get('https://httpbin.org/ip', {
  httpsAgent,
  headers: {
    'X-VP-Pool': 'residential',
    'X-VP-Country': 'US'
  }
});

console.log('Exit IP:', response.data.origin);

javascript

// Install: npm install axios https-proxy-agent

// Sticky session example
const sessionHeaders = {
  'X-VP-Session': 'user_session_42',
  'X-VP-Country': 'GB'
};

const r1 = await axios.get('https://example.com/login', { httpsAgent, headers: sessionHeaders });
const r2 = await axios.get('https://example.com/dashboard', { httpsAgent, headers: sessionHeaders });
// r1 and r2 exit from the same IP in Great Britain

Method 3: Python Scrapy Spider

Scrapy has built-in proxy support via middleware.

python

# settings.py
DOWNLOADER_MIDDLEWARES = {
    'scrapy.downloadermiddlewares.httpproxy.HttpProxyMiddleware': 110,
}
HTTP_PROXY = 'http://your_username:your_password@v-proxies.com:9000'
ROTATING_PROXY_LIST = ['http://your_username:your_password@v-proxies.com:9000']

python

# myspider.py
import scrapy

class ProductSpider(scrapy.Spider):
    name = "products"
    start_urls = ["https://example-shop.com/products"]

    custom_settings = {
        "DOWNLOADER_MIDDLEWARES": {
            "scrapy.downloadermiddlewares.httpproxy.HttpProxyMiddleware": 110,
        },
        "HTTP_PROXY": "http://user:pass@v-proxies.com:9000",
    }

    def parse(self, response):
        for product in response.css(".product-card"):
            yield {
                "title": product.css("h2::text").get(),
                "price": product.css(".price::text").get(),
            }

        next_page = response.css("a.next::attr(href)").get()
        if next_page:
            yield response.follow(next_page, self.parse)

Method 4: Puppeteer (Headless Browser)

For JavaScript-heavy sites that require a real browser:

javascript

const puppeteer = require('puppeteer');

const browser = await puppeteer.launch({
  args: [
    '--proxy-server=http://v-proxies.com:9000',
  ],
  headless: true,
});

const page = await browser.newPage();

// Authenticate with the proxy
await page.authenticate({
  username: 'your_username',
  password: 'your_password',
});

// Optional: set residential pool and geo via extra headers
await page.setExtraHTTPHeaders({
  'X-VP-Pool': 'residential',
  'X-VP-Country': 'US',
  'X-VP-City': 'LosAngeles',
});

await page.goto('https://example.com');
const content = await page.content();
console.log(content.substring(0, 500));

await browser.close();

Method 5: cURL (Command Line)

Perfect for quick tests and shell scripts:

bash

# Basic rotating residential request
curl -x "http://user:pass@v-proxies.com:9000" https://httpbin.org/ip

# Geo-targeted (Germany)
curl -x "http://user:pass@v-proxies.com:9000" \
     -H "X-VP-Country: DE" \
     https://httpbin.org/ip

# Sticky session
curl -x "http://user:pass@v-proxies.com:9000" \
     -H "X-VP-Session: my-session-001" \
     https://example.com/login

# Using SOCKS5
curl --socks5-hostname "v-proxies.com:9000" \
     -U "user:pass" \
     https://httpbin.org/ip

# Check your exit IP
curl -x "http://user:pass@v-proxies.com:9000" https://api.ipify.org

Method 6: Environment Variable (Universal)

Many HTTP clients respect the HTTP_PROXY and HTTPS_PROXY environment variables automatically:

bash

export HTTP_PROXY="http://user:pass@v-proxies.com:9000"
export HTTPS_PROXY="http://user:pass@v-proxies.com:9000"

# Now any HTTP client that respects these variables will use V-Proxies
python my_scraper.py
node my_bot.js

Troubleshooting Common Issues

Problem: ProxyError: Cannot connect to proxy

Cause: Wrong credentials or the proxy endpoint is unreachable. Fix:

1. Verify your username and password in the V-Proxies dashboard

2. Confirm your firewall allows outbound connections to port 9000

3. Test with cURL first: curl -x "http://user:pass@v-proxies.com:9000" https://httpbin.org/ip

Problem: SSL Certificate Errors

Cause: Some proxy configurations intercept SSL handshakes incorrectly. Fix: In Python requests: verify=False (for testing only) or pass the correct CA bundle. In production, ensure your proxy client is using HTTPS tunneling (CONNECT method), not MITM interception.

Problem: Requests Timing Out

Cause: Residential proxy peers can have variable latency depending on the device's home connection. Fix: Increase your timeout to at least 30–45 seconds. V-Proxies P50 latency is under 200ms but P95 can be higher.

python

requests.get(url, proxies=proxies, timeout=45)

Problem: Getting Blocked Despite Using Residential Proxies

Cause: Anti-bot systems use more than IP analysis — they check browser fingerprints, behavior timing, and JS rendering. Fix:

• Add realistic delays between requests (1–5 seconds)

• Rotate User-Agent headers along with IPs

• For JavaScript-heavy targets, use a headless browser (Puppeteer/Playwright) instead of requests

• Consider switching to mobile proxies (X-VP-Pool: mobile) for the most trust-heavy targets

Problem: Same IP Appearing Across Multiple Requests

Cause: You may be re-using the same HTTP session object, which maintains the connection and therefore the same upstream IP. Fix: Create a new session for each request, or omit the session header to ensure per-request rotation.

Performance Tips

Limit concurrent connections per target domain Even with rotating IPs, hammering a single domain with 500 concurrent requests looks suspicious. Limit concurrency to 10–50 per target domain.

Use datacenter proxies where you can V-Proxies datacenter proxies cost $0.80/GB and have P50 latency under 80ms. Use them for targets that don't actively block cloud IPs.

Cache what you can If you are scraping the same product pages repeatedly, cache responses locally. You pay per GB at V-Proxies — caching saves money and reduces target site load.

Monitor your bandwidth usage Use the V-Proxies dashboard or the REST API (GET /v1/usage) to monitor GB consumption in real time and avoid unexpected spend.

Frequently Asked Questions

Q: How do I test that my proxy is working?

bash

curl -x "http://user:pass@v-proxies.com:9000" https://api.ipify.org

This returns your current exit IP. Run it twice and you should see different IPs (rotating mode). If you see your own IP, the proxy is not correctly configured.

Q: Can I use residential proxies with Selenium? Yes. Pass the proxy via ChromeOptions or Firefox profile:

python

from selenium import webdriver
options = webdriver.ChromeOptions()
options.add_argument("--proxy-server=http://v-proxies.com:9000")
driver = webdriver.Chrome(options=options)

Then call driver.execute_cdp_cmd to set proxy authentication.

Q: How do I use residential proxies with async Python (httpx, aiohttp)?

python

import httpx
async with httpx.AsyncClient(proxies="http://user:pass@v-proxies.com:9000") as client:
    response = await client.get("https://httpbin.org/ip")
    print(response.json())

Q: What port does V-Proxies use? Port 9000 for HTTP/HTTPS. SOCKS5 is also available — check v-proxies.com/docs for the current SOCKS5 port.

Q: Do I need to install anything to use V-Proxies? No. V-Proxies is a hosted gateway — just point your HTTP client at v-proxies.com:9000 with your credentials.

Q: Can I use the V-Proxies CLI instead of a library? Yes. Install vp-cli and authenticate with vp-cli login. Full CLI reference at v-proxies.com/docs.

Summary

Using residential proxies is straightforward once you understand the connection model. The gateway endpoint is fixed (v-proxies.com:9000), authentication is standard HTTP proxy auth, and behavior is controlled through simple headers.

V-Proxies is designed for developers — a clean API, CLI, Python and Node.js SDKs, and documentation that actually answers real questions. At $0.99/GB with credits that never expire, it is the lowest-cost residential proxy option that does not require compromise on IP quality or feature set.

➡️ Set up your first residential proxy at V-Proxies →

Related Posts:

• What is a Residential Proxy?

• Rotating Residential Proxies Explained

• Residential Proxies for Web Scraping

• API Documentation

• V-Proxies Pricing