Selenium और Playwright में प्रॉक्सी authentication: सभी काम करने वाले तरीक़े (2026)

यह वह जाल है जिसमें हर browser-automation डेवलपर ठीक एक बार ज़रूर फँसता है: आप Chrome के launch flags में --proxy-server=http://user:pass@host:port जोड़ते हैं, ब्राउज़र ठीक से शुरू होता है, और फिर हर पेज एक authentication popup पर अटक जाता है जिसे आपकी स्क्रिप्ट न देख सकती है न क्लिक कर सकती है। Chrome चुपचाप प्रॉक्सी flag से credentials हटा देता है। कोई error नहीं, कोई log line नहीं, बस एक ऐसे ब्राउज़र में एक modal dialog जिसे कोई नहीं देख रहा।

यह गाइड प्रॉक्सी authentication के उन तरीक़ों का पूरा नक़्शा है जो 2026 में Selenium और Playwright में असल में काम करते हैं — कौन सा इस्तेमाल करें, किससे बचें, और हर एक का सटीक कोड। (इन टूल्स में प्रॉक्सी चयन और rotation रणनीति के लिए, Playwright & Puppeteer के साथ प्रॉक्सी का उपयोग देखें — यह लेख पूरी तरह credentials को पार पहुँचाने के बारे में है।)

user:pass@host ब्राउज़रों में क्यों फ़ेल होता है

Command-line HTTP क्लाइंट प्रॉक्सी URL से credentials parse करते हैं और प्रॉक्सी के 407 Proxy Authentication Required का जवाब अपने आप एक Proxy-Authorization header से देते हैं। Chromium ऐसा नहीं करता: --proxy-server केवल scheme://host:port स्वीकार करता है, और जब 407 वापस आता है तो यह एक interactive dialog दिखाता है। Headless mode में तो dialog भी नहीं होता — request बस fail हो जाती है।

तो सवाल कभी "मैं पासवर्ड को URL में कैसे डालूँ" नहीं होता — यह होता है "कौन सी layer मेरे लिए 407 का जवाब देती है।" चार काम करने वाले जवाब, सबसे अच्छा पहले।

Method 1: Playwright Native Auth (अगर कर सकें तो यही इस्तेमाल करें)

Playwright ने इस समस्या को ठीक से हल कर दिया: यह proxy auth challenges का जवाब CDP के ज़रिए ख़ुद देता है। Credentials launch या context options में जाते हैं:

# Python
from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(
        proxy={
            "server": "http://us.jibaoproxy.com:913",
            "username": "USERNAME-session-job1",
            "password": "PASSWORD",
        }
    )

// Node.js - and per-context, which is where it gets powerful:
const browser = await chromium.launch({
  proxy: { server: 'per-context' }   // declare intent at launch
});
const ctx = await browser.newContext({
  proxy: {
    server: 'http://us.jibaoproxy.com:913',
    username: 'USERNAME-session-job2',
    password: 'PASSWORD',
  }
});

Per-context प्रॉक्सी का मतलब है कि एक ब्राउज़र प्रोसेस N अलग-अलग sticky sessions पर N contexts चला सकता है — हर गंभीर Playwright scraping सेटअप की नींव। अगर आप Playwright पर हैं, तो आपका काम हो गया; सीधे verification सेक्शन पर जाएँ। नीचे की हर चीज़ इसलिए मौजूद है क्योंकि Selenium के पास इसका कोई समकक्ष नहीं है।

Method 2: selenium-wire (Selenium, Python)

selenium-wire Selenium को एक local MITM प्रॉक्सी से लपेटता है जो upstream authentication संभालता है:

from seleniumwire import webdriver   # pip install selenium-wire

options = {
    "proxy": {
        "http":  "http://USERNAME:[email protected]:913",
        "https": "https://USERNAME:[email protected]:913",
    }
}
driver = webdriver.Chrome(seleniumwire_options=options)
driver.get("https://example.com")

production से पहले आपको जो चेतावनियाँ जाननी चाहिए:

• यह TLS को स्थानीय रूप से decrypt करता है (इसी तरह यह auth inject करता है), इसलिए ब्राउज़र को selenium-wire का certificate दिखता है। scraping के लिए ठीक है; certificate-pinned targets को तोड़ देता है।
• सारा traffic एक local Python प्रोसेस से होकर गुज़रता है — भारी parallelism के आसपास एक throughput सीमा की अपेक्षा करें।
• मूल प्रोजेक्ट हल्के ढंग से maintain किया जाता है; अपने version को pin करें और upgrades के बाद टेस्ट करें।

Method 3: Credentials inject करने वाला Chrome Extension (Selenium, कोई भी भाषा)

क्लासिक तरीक़ा: एक छोटा generated extension जो प्रॉक्सी सेट करता है और chrome.webRequest.onAuthRequired के ज़रिए auth का जवाब देता है। कोई MITM नहीं, कोई अतिरिक्त प्रोसेस नहीं, साधारण Selenium में काम करता है:

import zipfile, json

HOST, PORT = "us.jibaoproxy.com", 913
USER, PASS = "USERNAME-session-sel1", "PASSWORD"

manifest = {
    "version": "1.0.0", "manifest_version": 2, "name": "Proxy Auth",
    "permissions": ["proxy", "webRequest", "webRequestBlocking", ""],
    "background": {"scripts": ["background.js"]},
}
background = f"""
chrome.proxy.settings.set({{value: {{mode: "fixed_servers", rules: {{
  singleProxy: {{scheme: "http", host: "{HOST}", port: {PORT}}}
}}}}, scope: "regular"}}, () => {{}});
chrome.webRequest.onAuthRequired.addListener(
  () => ({{authCredentials: {{username: "{USER}", password: "{PASS}"}}}}),
  {{urls: [""]}}, ["blocking"]
);
"""

with zipfile.ZipFile("proxy_auth.zip", "w") as zp:
    zp.writestr("manifest.json", json.dumps(manifest))
    zp.writestr("background.js", background)

from selenium import webdriver
opts = webdriver.ChromeOptions()
opts.add_extension("proxy_auth.zip")
driver = webdriver.Chrome(options=opts)

दो पेच: extensions क्लासिक headless mode में लोड नहीं होते — --headless=new (Chrome 109+) इस्तेमाल करें या headed चलाएँ; और Manifest V2 background scripts sideloaded automation extensions के लिए अब भी काम करते हैं लेकिन Chrome की MV2 deprecation timeline पर नज़र रखें — MV3 समकक्ष को एक service worker और वही onAuthRequired listener चाहिए।

Method 4: Local Forwarder (सार्वभौमिक Fallback)

एक छोटा local प्रॉक्सी चलाएँ जो credentials रखता है; ब्राउज़र को बिना किसी auth के localhost की ओर इंगित करें। हर ब्राउज़र, हर driver, हर भाषा, headless हो या न हो, के साथ काम करता है:

# Using pproxy (pip install pproxy) - terminal 1:
pproxy -l http://127.0.0.1:8899 \
       -r "http://USERNAME:[email protected]:913"

# Your script - terminal 2: plain Selenium, no auth needed
opts = webdriver.ChromeOptions()
opts.add_argument("--proxy-server=http://127.0.0.1:8899")
driver = webdriver.Chrome(options=opts)

यह Firefox/geckodriver के लिए भी सबसे साफ़ जवाब है (जहाँ extension वाली तरकीब लागू नहीं होती) और Electron app testing जैसे असामान्य environments के लिए भी। क़ीमत: देखरेख के लिए एक और घटक, और per-context routing के लिए प्रति session एक forwarder port चाहिए।

Method की तुलना

Method	किसमें काम करता है	Headless	Per-context sessions	Production फ़ैसला
Playwright native	Playwright	हाँ	हाँ	डिफ़ॉल्ट विकल्प
selenium-wire	Selenium (Py)	हाँ	Per-driver	मध्यम पैमाने पर ठीक
Auth extension	Selenium (कोई भी भाषा)	केवल --headless=new	Per-driver	ठोस, MV3 पर नज़र रखें
Local forwarder	हर चीज़	हाँ	प्रति session एक port	सार्वभौमिक fallback

सत्यापित करें कि यह असल में काम कर गया

आपके असली IP पर चुपचाप fallback वह failure mode है जो अकाउंट्स को बैन करवाता है। हर run की शुरुआत में exit IP को assert करें:

ip = driver.execute_script(
    "return fetch('https://api.ipify.org').then(r => r.text())"
) if hasattr(driver, 'execute_script') else page.evaluate(
    "fetch('https://api.ipify.org').then(r => r.text())"
)
assert ip != MY_REAL_IP, "Proxy not applied - aborting before we leak"

Troubleshooting त्वरित संदर्भ

• Auth popup दिखता है — आपने credentials --proxy-server में पास किए; Chrome ने उन्हें हटा दिया। चार तरीक़ों में से एक इस्तेमाल करें।
• ERR_PROXY_CONNECTION_FAILED — host/port ग़लत या protocol mismatch। पहले वही line curl -x के साथ टेस्ट करें; अगर curl काम करता है, तो समस्या आपकी ब्राउज़र wiring में है।
• Headed में काम करता है, headless में fail — क्लासिक headless में extension method। --headless=new पर स्विच करें।
• कुछ random requests प्रॉक्सी को bypass करती हैं — WebRTC और service workers ग़लत कॉन्फ़िगर किए सेटअप के इर्द-गिर्द रास्ता बना सकते हैं; ऊपर वाले IP assert से सत्यापित करें, दृश्य निरीक्षण से नहीं।
• SOCKS5 + Selenium + auth — Chromium authenticated SOCKS5 को मूल रूप से बिल्कुल भी नहीं करता; forwarder (Method 4) इस्तेमाल करें या उसी gateway पर HTTP पर स्विच करें।

सारांश

ब्राउज़र user:pass@ प्रॉक्सी URL नहीं पढ़ते — किसी न किसी को उनके लिए 407 का जवाब देना होता है। Playwright में वह कोई चीज़ बिल्ट-इन है; Selenium में यह selenium-wire है, एक generated auth extension है, या एक local forwarder है। तुलना तालिका से अपने stack के अनुसार चुनें, फिर हर run पर exit IP को assert करें ताकि एक चुपचाप auth failure कभी भी crawl के बीच में आपके असली पते को leak न कर सके।