Python में प्रॉक्सी रोटेट करें: requests, httpx और aiohttp (2026 गाइड)

अगर आप Python में किसी भी पैमाने पर scrape, crawl, या automate करते हैं, तो देर-सबेर target साइट को पता चल जाता है कि हर request एक ही IP से आ रही है और वह आपको बंद कर देती है। Python में rotating proxies आपके traffic को कई IP पतों में फैला देते हैं ताकि कोई एक भी किसी rate limit को न छुए या बैन न कमाए। यह गाइड requests, httpx, और aiohttp के लिए सटीक कोड दिखाती है, साथ ही एक rotating gateway और एक managed IP pool के बीच कैसे चुनें।

दो व्यापक फ़ैसले नीचे की हर चीज़ को आकार देते हैं। पहला: rotating बनाम sticky sessions — प्रति request एक नया IP, या एक बहु-चरण flow के लिए एक IP बनाए रखना। दूसरा: residential बनाम datacenter IPs — प्रॉक्सी-टाइप निर्णय मैट्रिक्स देखें। इन दोनों को सही कर लें और कोड आसान हिस्सा है।

Rotate करने के दो तरीक़े

1. Gateway rotation (अनुशंसित)। आप एक ही endpoint से जुड़ते हैं और प्रोवाइडर हर नए connection पर आपको एक नया exit IP देता है। प्रबंधित करने के लिए कोई सूची नहीं, छाँटने के लिए कोई मृत IP नहीं। JIBAO का dynamic residential pool इसी तरह काम करता है: वही host और port, हर request पर एक नया IP।

2. स्वयं-प्रबंधित IP सूची। आप host:port entries की एक सूची रखते हैं और प्रति request एक चुनते हैं। ज़्यादा नियंत्रण, लेकिन health-checking, retries, और ban-tracking आपके ज़िम्मे। तब उपयोगी जब आपको ज्ञात, स्थिर पते चाहिए, समर्पित datacenter IPs के साथ।

requests के साथ Rotation

सबसे सरल मामला — एक request को ऐसे gateway के ज़रिए route करना जो आपके लिए rotate करता है। socks5h:// इस्तेमाल करें (आख़िरी h का मतलब है कि DNS प्रॉक्सी की ओर resolve होता है, जो lookups को leak होने से बचाता है):

import requests

# JIBAO rotating residential gateway: a new exit IP per connection
PROXY = "socks5h://USERNAME:[email protected]:10001"

proxies = {"http": PROXY, "https": PROXY}

for _ in range(5):
    r = requests.get("https://httpbin.org/ip", proxies=proxies, timeout=30)
    print(r.json()["origin"])   # a different IP each loop

requests को SOCKS5 बोलवाना है? extra इंस्टॉल करें: pip install "requests[socks]"। अगर आप एक HTTP प्रॉक्सी endpoint पसंद करते हैं, तो scheme को http:// में बदलें — बाक़ी एक जैसा है।

अपनी ख़ुद की IP सूची से Rotation

import random
import requests

PROXY_POOL = [
    "socks5h://USERNAME-country-us:[email protected]:10001",
    "socks5h://USERNAME-country-uk:[email protected]:10001",
    "socks5h://USERNAME-country-de:[email protected]:10001",
]

def fetch(url):
    proxy = random.choice(PROXY_POOL)
    return requests.get(url, proxies={"http": proxy, "https": proxy}, timeout=30)

resp = fetch("https://example.com")
print(resp.status_code)

जब आपको एक IP बनाए रखना ही हो तो Sticky sessions

Login flows, carts, और paginated results टूट जाते हैं अगर task के बीच में IP बदल जाए। username में एक session token जोड़कर एक IP pin करें; उसी token को फिर से इस्तेमाल करके उसके जीवनकाल तक वही exit IP बनाए रखें:

import requests

SESSION_ID = "task-0001"
PROXY = f"socks5h://USERNAME-session-{SESSION_ID}:[email protected]:10001"

s = requests.Session()
s.proxies = {"http": PROXY, "https": PROXY}

s.post("https://example.com/login", data={"u": "me", "p": "secret"})
s.get("https://example.com/dashboard")   # same IP, session intact

httpx के साथ Rotation

httpx आपको HTTP/2 और native async के साथ एक आधुनिक client देता है। ध्यान दें कि नए versions एक single proxy= argument लेते हैं:

import httpx

PROXY = "socks5h://USERNAME:[email protected]:10001"

with httpx.Client(proxy=PROXY, timeout=30) as client:
    for _ in range(5):
        print(client.get("https://httpbin.org/ip").json()["origin"])

httpx में SOCKS support के लिए pip install "httpx[socks]" चाहिए। HTTP/2 के लिए, client में http2=True जोड़ें — यह आपके traffic को एक असली ब्राउज़र जैसा दिखाता है, जो TLS fingerprint matching के साथ अच्छा जोड़ बनाता है।

aiohttp के साथ Concurrent rotation

उच्च throughput के लिए, एक साथ कई requests दागें। gateway के ज़रिए हर connection को अपना exit IP मिलता है, इसलिए concurrency और rotation एक साथ आते हैं:

import asyncio
import aiohttp
from aiohttp_socks import ProxyConnector

PROXY = "socks5://USERNAME:[email protected]:10001"

async def fetch(url):
    connector = ProxyConnector.from_url(PROXY)
    async with aiohttp.ClientSession(connector=connector) as session:
        async with session.get(url, timeout=aiohttp.ClientTimeout(total=30)) as r:
            return await r.text()

async def main():
    urls = ["https://httpbin.org/ip"] * 20
    results = await asyncio.gather(*(fetch(u) for u in urls))
    print(f"fetched {len(results)} pages")

asyncio.run(main())

SOCKS connector को pip install aiohttp_socks से इंस्टॉल करें। प्रति task एक नया connector बनाएँ ताकि हर request एक नया proxied connection खोले।

Retry Logic जो असल में मदद करता है

Rotation तभी फ़ायदेमंद है जब आप failures को एक नए IP पर retry करें। exponentially back off करें और हर प्रयास पर session token rotate करें:

import requests
from time import sleep

def fetch_with_retry(url, max_retries=4):
    for attempt in range(max_retries):
        proxy = f"socks5h://USERNAME-session-r{attempt}:[email protected]:10001"
        try:
            r = requests.get(url, proxies={"http": proxy, "https": proxy}, timeout=30)
            if r.status_code in (403, 429):
                raise requests.HTTPError(f"blocked: {r.status_code}")
            r.raise_for_status()
            return r.text
        except requests.RequestException:
            sleep(2 ** attempt)        # 1s, 2s, 4s, 8s
    raise RuntimeError(f"failed after {max_retries} tries: {url}")

सत्यापित करें कि आपका Rotation काम कर रहा है

एक बड़े run से पहले, पुष्टि करें कि IP असल में बदलता है। एक echo endpoint को कुछ बार हिट करें और जाँचें कि IPs अलग हैं। यह भी पुष्टि करने के लिए कि आपका TLS fingerprint आपकी पोल नहीं खोल रहा, request को JIBAO के मुफ़्त JA3/TLS fingerprint checker के विरुद्ध चलाएँ — एक dead-giveaway Python fingerprint वाला rotating IP भी block हो जाता है।

सर्वोत्तम प्रथाएँ

• प्रति task rotate करें, प्रति step नहीं। किसी भी बहु-request workflow के लिए एक sticky session इस्तेमाल करें; स्वतंत्र tasks के बीच rotate करें।
• IP टाइप को target से मिलाएँ। permissive APIs के लिए Datacenter ($0.8/GB), Cloudflare या Akamai के पीछे की साइटों के लिए residential ($2/GB)।
• हर request पर timeouts सेट करें। बिना timeout के एक अटका हुआ proxied connection आपके पूरे crawl को रोक देगा।
• Bandwidth पर नज़र रखें। Residential प्रति GB बिल करता है — एक भारी पेज पर एक redirect loop तेज़ी से क्रेडिट जला देता है।
• robots.txt और rate limits का सम्मान करें। किसी target को पीटना पूरे IP ranges को flag करवा देता है और pool पर सबको नुक़सान पहुँचाता है।

एक बार rotation ठोस हो जाए, तो अगली दीवार जिससे आप टकराते हैं वह आमतौर पर fingerprinting होती है, IPs नहीं। अगर साफ़ residential IPs अब भी 403 पाते हैं, तो पढ़ें curl_cffi के साथ TLS fingerprinting को कैसे bypass करें और पूरी Cloudflare bypass रेसिपी।