बिना Extension के Botasaurus में CAPTCHA कैसे हल करें

botasaurus captcha - How to Solve CAPTCHA in Botasaurus Without an Extension

Botasaurus का captcha टास्क के अंदर ही संभालना सबसे आसान है, ब्राउज़र एक्सटेंशन के ज़रिए नहीं। फ्रेमवर्क के अपने डॉक्यूमेंटेशन में एक पेड क्लाउड एक्सटेंशन बताया गया है, जो चैलेंज को अदृश्य रूप से हल करता है और हर कोशिश के लिए बिल करता है। अपने decorated function से सीधे एक सॉल्वर को कॉल करना कम कोड में होता है, और यह आपको token एक साधारण Python वैल्यू के रूप में देता है जिसे आप लॉग कर सकते हैं, उस पर शाखा बना सकते हैं और दोबारा कोशिश कर सकते हैं। यह गाइड sitekey पढ़ने, हल करने, driver.run_js से जवाब इंजेक्ट करने, और उन दो decorator विकल्पों को कवर करती है जो चुपचाप पूरी चीज़ को तोड़ देते हैं।

आपको क्या चाहिए

  • Python 3.10 या उससे नया, जिसे दोनों packages टारगेट करते हैं
  • Botasaurus इंस्टॉल किया हुआ, साथ ही सॉल्वर क्लाइंट
  • CapSkip चालू और पहुँच योग्य हो। जब स्क्रैपर उसी मशीन पर चलता है तो Local mode 127.0.0.1 पोर्ट 8080 पर सुनता है, और Server mode आपके नेटवर्क या पब्लिक IP पर सुनता है ताकि कोई VPS या कंटेनर होस्ट इसे कॉल कर सके। देखें: कनेक्शन सेटिंग्स दोनों के लिए।
  • एक ऐसा पेज जिस पर असली widget मौजूद हो। sitekey लाइव DOM से ही लेना होगा, क्योंकि यह हर साइट के हिसाब से अलग होती है
# The scraper and the solver client, in one line.
python -m pip install --upgrade botasaurus capskip

एक्सटेंशन वाला रास्ता क्यों नहीं

Botasaurus decorator के ज़रिए Chrome एक्सटेंशन को सपोर्ट करता है, और इसका डॉक्यूमेंटेशन एक CapSolver एक्सटेंशन को API key के साथ जोड़ा हुआ दिखाता है। यह काम करता है। लेकिन यह तीन चीज़ें भी आपकी ओर से तय कर देता है, जिन पर ध्यान देना ज़रूरी है।

आप token को कभी देखते ही नहीं। एक्सटेंशन जवाब को अपने ही समय पर पेज में लिखता है, इसलिए आपके कोड के पास जाँचने के लिए कोई वैल्यू नहीं होती। जब कोई हल फ़ेल होता है, तो आपको एक ऐसा पेज मिलता है जिस पर अभी भी एक अनसुलझा widget मौजूद रहता है, जो बाद में फ़ेलियर की जगह पर एक exception के बजाय एक उलझन भरी फॉर्म एरर के रूप में सामने आता है।

हर कोशिश का बिल बनता है। प्रति-हल वाला क्लाउड API दोबारा कोशिशों को एक बिल आइटम बना देता है। Botasaurus में यह असर सामान्य से भी तेज़ होता है, क्योंकि max_retry पूरे decorated function को फिर से चलाता है और parallel विकल्प इसे ब्राउज़रों की संख्या से गुणा कर देता है। दस वर्कर्स, हर एक तीन दोबारा कोशिशों के साथ, यह एक आम दोपहर में हो सकता है और एक ऐसा बिल दे सकता है जिसकी आपने योजना नहीं बनाई थी। सॉल्वर को अपने ही हार्डवेयर पर चलाना यह पूरा हिसाब हटा देता है, और यह दलील विस्तार से यहाँ दी गई है: CapSolver विकल्प वाले पेज.

आपकी API key ब्राउज़र तक पहुँच जाती है। एक एक्सटेंशन पूरी key समेत Chrome instance में लोड हो जाता है। एक लोकल सॉल्वर सिर्फ़ आपकी Python प्रोसेस से एक request लेता है, और कुछ नहीं।

स्टेप 1: टास्क के अंदर sitekey पढ़ें

सब कुछ decorated function के अंदर होता है, जहाँ आपके पास पहले से एक driver मौजूद होता है।

# python -m pip install botasaurus
from botasaurus.browser import browser, Driver, Wait

@browser(block_images=True)
def solve_login(driver: Driver, data):
    driver.get("https://example.com/page-with-recaptcha")

    # The widget is injected by script, so wait for it
    # rather than reading the DOM immediately.
    widget = driver.select("[data-sitekey]", wait=Wait.LONG)
    sitekey = widget.get_attribute("data-sitekey")

    return {"sitekey": sitekey}   # written to output/solve_login.json

यहाँ Botasaurus की दो आदतें समझनी ज़रूरी हैं। select कॉल एरर उठाने के बजाय element या None लौटाता है, इसलिए अगर आप जाँच न करें तो एक गायब widget एक लाइन बाद NoneType एरर के रूप में सामने आता है। और आप जो भी रिटर्न करते हैं वह output directory के अंदर एक JSON फ़ाइल में लिखा जाता है, जिसका नाम फ़ंक्शन के नाम पर होता है, जिससे बनाते समय एक आधे-अधूरे टास्क को जाँचना आसान हो जाता है।

स्टेप 2: हल करें, फिर driver.run_js से इंजेक्ट करें

Botasaurus ब्राउज़र को Selenium के ज़रिए नहीं चलाता, इसलिए कहीं और मिलने वाले execute_script वाले तरीके यहाँ लागू नहीं होते। इसका बराबर driver.run_js है, और यह अपने दूसरे पैरामीटर के रूप में एक arguments ऑब्जेक्ट लेता है।

# python -m pip install capskip
from capskip import CapSkip

solver = CapSkip(host="127.0.0.1", port=8080)

result = solver.recaptcha(
    sitekey=sitekey,
    url="https://example.com/page-with-recaptcha",
)

# args is how Botasaurus passes Python values into the page.
driver.run_js(
    "document.getElementById('g-recaptcha-response').value = args.token",
    {"token": result["code"]},
)

यही कॉल पूरे reCAPTCHA परिवार को कवर करती है। अदृश्य widget के लिए invisible दें, Enterprise के लिए enterprise, और v3 के लिए action के साथ v3 वर्शन दें। Turnstile और GeeTest अलग-अलग methods हैं लेकिन उनका आकार वही है। v3 के लिए आप min_score भी दे सकते हैं: CapSkip इसे स्वीकार करता है ताकि दूसरी सेवाओं से लाया गया कोड चलता रहे, लेकिन इससे token नहीं बदलता, क्योंकि स्कोर Google तय करता है।

अगर widget वाले div में एक data-callback एट्रिब्यूट है, तो फॉर्म सबमिट करने के बजाय उस फ़ंक्शन को token के साथ कॉल करें। इस तरह बने पेज कभी एक सामान्य submit handler नहीं जोड़ते, इसलिए बटन पर क्लिक करने से कुछ भी नहीं होता।

पूरा काम करने वाला उदाहरण

# python -m pip install botasaurus capskip
from botasaurus.browser import browser, Driver, Wait
from capskip import CapSkip, NetworkException, TimeoutException

solver = CapSkip(host="127.0.0.1", port=8080)
PAGE = "https://example.com/page-with-recaptcha"

@browser(block_images=True, max_retry=3, retry_wait=10)
def scrape_behind_recaptcha(driver: Driver, data):
    driver.get(PAGE)

    widget = driver.select("[data-sitekey]", wait=Wait.LONG)
    if widget is None:
        return {"error": "no widget on the page"}

    try:
        result = solver.recaptcha(
            sitekey=widget.get_attribute("data-sitekey"),
            url=driver.run_js("return location.href"),
        )
    except (NetworkException, TimeoutException) as exc:
        # Raising here lets max_retry take another run at it.
        raise RuntimeError(f"solve failed: {exc}")

    driver.run_js(
        "document.getElementById('g-recaptcha-response').value = args.token",
        {"token": result["code"]},
    )
    driver.click("button[type='submit']")

    return {"title": driver.run_js("return document.title")}

scrape_behind_recaptcha()

ध्यान दें कि पेज URL constant से नहीं बल्कि ब्राउज़र से आता है। अगर साइट ने रास्ते में रीडायरेक्ट किया था, तो जिस URL के ख़िलाफ़ widget रेंडर हुआ था वही URL हल के लिए ज़रूरी है, और अपना ख़ुद का लिखा हुआ literal दोबारा इस्तेमाल करना उस token की सबसे आम वजह है जिसे server बाद में ठुकरा देता है।

दो decorator विकल्प जो हल को तोड़ देते हैं

दोनों ऐसी चीज़ें हैं जो Botasaurus सही तरीके से करता है, और यही वजह है कि जब कोई CAPTCHA शामिल होता है तो ये उलझन पैदा करती हैं।

Caching लौटाई गई वैल्यू को स्टोर करती है, जो input पर keyed होती है। इसे चालू करें, वही input दूसरी बार चलाएँ, और फ्रेमवर्क बिना ब्राउज़र खोले स्टोर किया गया dictionary लौटा देता है, इसलिए न कोई हल होता है और न कोई request सॉल्वर तक पहुँचती है। जब आप एक बड़े स्क्रैप को दोबारा चला रहे हों तो यह एक फ़ीचर है। जब आप एक पेज को डीबग कर रहे हों तो यह एक टूटे हुए इंटीग्रेशन जैसा दिखता है, इसलिए काम करते समय cache साफ़ करें या विकल्प हटा दें।

decorator पर मौजूद proxy विकल्प ब्राउज़र की proxy है, सॉल्वर की नहीं। ये अलग-अलग सेटिंग्स हैं और इनका आपस में मेल खाना ज़रूरी है। जब ब्राउज़र एक residential proxy के पीछे बैठा हो और token आपके अपने IP से बना हो, तो यह एक ऐसा मिसमैच है जिसे साइट देख सकती है, और यही वजह है कि जो हल अकेले टेस्ट करने पर ठीक साबित होता है वह असली फ़्लो के अंदर फ़ेल हो जाता है। हल वाली कॉल को भी वही endpoint दें:

PROXY = "user:[email protected]:3128"

@browser(proxy=f"http://{PROXY}")
def scrape(driver: Driver, data):
    result = solver.recaptcha(
        sitekey=sitekey,
        url=PAGE,
        proxy={"type": "HTTPS", "uri": PROXY},
    )

Proxies reCAPTCHA, Turnstile, GeeTest और CaptchaFox पर लागू होती हैं। Image CAPTCHA इसे नहीं लेते, क्योंकि रूट करने के लिए किसी तीसरे पक्ष को कोई request ही नहीं जाती।

एक साथ कई ब्राउज़र चलाना

यहीं पर एक लोकल सॉल्वर अपनी जगह बनाता है। decorator पर parallel विकल्प सेट करने से उतने ही ब्राउज़र शुरू हो जाते हैं, हर एक अपने ही input के साथ आपका फ़ंक्शन चलाता है, और हर एक अपने ही चैलेंज से टकराता है।

@browser(parallel=8, reuse_driver=True, block_images=True)
def scrape_behind_recaptcha(driver: Driver, data):
    ...

scrape_behind_recaptcha([url1, url2, url3])

एक client ऑब्जेक्ट सभी आठ के बीच शेयर करना सुरक्षित है, क्योंकि हर कॉल एक स्वतंत्र HTTP request होती है। SDK 250 मिलीसेकंड पर polling शुरू करता है और pollingInterval की सीमा तक धीमा होता जाता है, इसलिए एक साथ कई हल चलने पर भी एक तेज़ हल तेज़ ही बना रहता है। क्षमता एक हार्डवेयर का सवाल है, बिलिंग का नहीं, और यही वजह है कि आठ वर्कर्स एक ऐसा उचित डिफ़ॉल्ट बन जाता है जिसे सही ठहराने की ज़रूरत नहीं पड़ती। स्क्रैपिंग के व्यापक पैटर्न यहाँ बताए गए हैं: वेब स्क्रैपिंग पेज.

इसके बजाय CapSkip को server पर चलाना

Botasaurus स्क्रैपर आमतौर पर लैपटॉप के अलावा कहीं और पहुँच जाते हैं: एक VPS, एक Docker host, एक शेड्यूल्ड बॉक्स। Loopback वहाँ तक इनका साथ नहीं देता।

मोडकिस पर सुनता हैकब इस्तेमाल करें
लोकल127.0.0.1, केवल उसी डिवाइस परस्क्रैपर और सॉल्वर एक ही मशीन शेयर करते हैं
सर्वरआपका network या public IPस्क्रैपर एक VPS, एक container या किसी दूसरे बॉक्स पर चलता है

सिर्फ़ constructor बदलता है। SDK अपने आप CAPSKIP_HOST या CAPSKIP_PORT नहीं पढ़ता, इसलिए नीचे वाला constructor इन्हें environment से पढ़ता है, और फिर डिप्लॉय किए गए स्क्रैपर को कोड बदलाव की नहीं, बल्कि बस इन दो variables की ज़रूरत होती है।

import os
from capskip import CapSkip

# Same client, different address. The task never changes.
solver = CapSkip(
    host=os.getenv("CAPSKIP_HOST", "127.0.0.1"),
    port=int(os.getenv("CAPSKIP_PORT", "8080")),
)

सॉल्वर बॉक्स के लिए एक static public IP की सलाह दी जाती है ताकि पता स्थिर बना रहे, और इसके चरण यहाँ देखें: कनेक्शन सेटिंग्स। यह अब भी आपका ही हार्डवेयर है और अब भी अनमीटर्ड है। बस इतना बदला है कि प्रोसेस कहाँ सुन रही है।

आम errors और उनका मतलब

लक्षणकारणफिक्स
NoneType पर AttributeErrorselect कॉल को कुछ नहीं मिला और उसने None लौटायाएक wait आर्गुमेंट दें, फिर एट्रिब्यूट पढ़ने से पहले None की जाँच करें
टास्क तुरंत रिटर्न हो जाता है और कोई ब्राउज़र नहीं खुलताCaching ने उस input के लिए एक स्टोर किया गया परिणाम दे दियाडीबग करते समय cache साफ़ करें या विकल्प हटा दें
पहले हल पर NetworkExceptionउस host और port पर कोई नहीं सुन रहाCapSkip शुरू करें, या अगर स्क्रैपर रिमोट है तो Server mode पर स्विच करें
ERROR_GOOGLEKEYsitekey किसी Turnstile widget का है, या अधूरा कट गया हैहल करने से पहले एट्रिब्यूट प्रिंट करें; Turnstile का अपना अलग method है
ERROR_PAGEURLएक हार्डकोड किया गया URL जो अब पेज से मेल नहीं खाताइसके बजाय पता ब्राउज़र से ही पढ़ें
फॉर्म सबमिट होता है और server token को ठुकरा देता हैपेज एक callback इस्तेमाल करता है, इसलिए अकेला hidden field काफ़ी नहीं हैdata-callback फ़ंक्शन को token के साथ कॉल करें
अकेले काम करता है, proxy के पीछे फ़ेल होता हैब्राउज़र proxied है और हल नहीं हैदोनों को एक ही endpoint दें

हर parameter और हर error string यहाँ दी गई है: API डॉक्यूमेंटेशन.

अक्सर पूछे जाने वाले सवाल

क्या इसके बजाय request decorator काम करता है?

नहीं, और Botasaurus का डॉक्यूमेंटेशन साफ़ बताता है कि क्यों: request decorator ब्राउज़र जैसी HTTP कॉल तो करता है लेकिन JavaScript नहीं चला सकता, और चैलेंज widget JavaScript है। जिस पेज पर widget है उसके लिए browser decorator इस्तेमाल करें। एक बार आपके पास session आ जाने के बाद, उसके पीछे वाले पेजों के लिए request task अब भी सही टूल है।

widget के बजाय Cloudflare वाले interstitial का क्या?

ये दो अलग-अलग चीज़ें हैं, और Botasaurus पहली को पहले से ही संभाल लेता है। साइट लोड होने से पहले मिलने वाला पूरे पेज का interstitial ही वह चीज़ है जिसके लिए google_get पर मौजूद bypass_cloudflare आर्गुमेंट है। लॉगिन फॉर्म के अंदर बैठा एक Turnstile widget एक सामान्य पेज पर एक सामान्य चैलेंज है, और इसे किसी भी दूसरे की तरह एक token चाहिए, इसलिए इसे हल करें और जवाब को cf-turnstile-response फ़ील्ड में लिखें।

क्या मैं इसे बिना डिस्प्ले वाले server पर headless चला सकता हूँ?

हाँ। Botasaurus में एक headless विकल्प और बिना डिस्प्ले वाले Linux बॉक्स के लिए एक X virtual framebuffer विकल्प है, और इनमें से कोई भी हल को नहीं छूता, क्योंकि वह आपकी Python प्रोसेस से होने वाली एक HTTP कॉल है। client को Server mode के साथ एक पहुँच योग्य पते पर पॉइंट करें और वही टास्क बिना बदले किसी VPS पर चल जाता है।

क्या हल एक अलग task decorator में जाना चाहिए?

जा सकता है, और जब कई स्क्रैपर एक ही हल रूटीन शेयर करते हैं तो यह साफ़-सुथरा रहता है। task decorator आपकी पसंद का कोई भी Python चलाता है, उसके पीछे वही caching और retry मशीनरी लगी रहती है। जब token को उसी पेज में वापस जाना हो जहाँ से वह आया था, तो इसे browser फ़ंक्शन में ही रखें, क्योंकि इसे अलग करने का मतलब है driver को बिना किसी फ़ायदे के इधर-उधर पास करना।

संक्षेप में

sitekey को एक wait वाले select से पढ़ें, decorated function के अंदर से हल करें, और driver.run_js व उसके args ऑब्जेक्ट से token को पेज में लिखें। एक्सटेंशन को छोड़ दें: token को एक वैल्यू के रूप में पकड़े रहना ही आपको सोच-समझकर दोबारा कोशिश करने देता है, और यह API key को ब्राउज़र से बाहर रखता है।

जिन दो विकल्पों पर नज़र रखनी चाहिए वे हैं caching, जो एक स्टोर किया गया परिणाम लौटा देगी और कभी ब्राउज़र नहीं खोलेगी, और proxy सेटिंग, जो ब्राउज़र को कवर करती है, हल को नहीं। सॉल्वर ख़ुद चलाना ही दोबारा कोशिश को मुफ़्त बनाता है, और यही पूरी वजह है कि कैप्चा बायपास आठ वर्कर्स पर एक क्षमता का फ़ैसला है, बजट का नहीं। Client विकल्प यहाँ बताए गए हैं: Python इंटीग्रेशन गाइड, और फ्रेमवर्क का अपना संदर्भ यहाँ मिलता है: Botasaurus रिपॉज़िटरी.