Scarnox · Blog

Python से PopularCaptcha कैसे हल करें (काम करने वाला उदाहरण, 2026)

अगर आपकी Python स्क्रिप्ट किसी PopularCaptcha से टकराई है, तो आपको ब्राउज़र फ़ार्म या अपना कोई मॉडल नहीं चाहिए। आपको पेज का sitekey, एक POST रिक्वेस्ट, और उससे लौटने वाला टोकन चाहिए।

यह गाइड आपको लगभग पांच मिनट में एक काम करने वाले टोकन तक ले जाती है: API key लें, sitekey खोजें, टोकन मांगें, उसे फॉर्म में सबमिट करें, और उन विफलताओं को संभालें जो बिना निगरानी चलने वाली स्क्रिप्ट में आती हैं। विफल सॉल्व मुफ्त हैं, इसलिए रिट्राई में केवल समय जाता है।

Scarnox आज PopularCaptcha हल करता है, proxyless या अपनी proxy के साथ। reCAPTCHA, Cloudflare Turnstile और AWS WAF जैसे दूसरे कैप्चा जल्द आ रहे हैं, इसलिए यहां हर उदाहरण PopularCaptcha का है। कैप्चा टाइप का अवलोकन बताता है कि बाकी कैसे अलग हैं।

1. API key लें

खाता बनाएं और मुफ्त ट्रायल क्रेडिट के साथ शुरू करें, कार्ड की ज़रूरत नहीं। आपकी API key डैशबोर्ड पर है। उसे सोर्स कोड से बाहर रखें, और environment variable से पढ़ें:

export SCARNOX_KEY="scarnox_YOURAPIKEY"

2. sitekey खोजें

कैप्चा वाला पेज खोलें, DevTools खोलें, और Elements पैनल में data-sitekey खोजें। PopularCaptcha के sitekey UUID होते हैं:

<div class="h-captcha" data-sitekey="10000000-ffff-ffff-ffff-000000000001"></div>

HTML में data-sitekey नहीं है? विजेट शायद JavaScript से रेंडर हुआ है। Network टैब में विजेट की कॉन्फ़िगरेशन रिक्वेस्ट देखें; उसका sitekey क्वेरी पैरामीटर वही है जो आपको चाहिए। iframe URL और invisible विजेट के बारे में sitekey खोजने के दूसरे तरीके में है।

विजेट दिखाने वाले पेज का URL site_url के रूप में भेजें। होस्ट सबसे ज़्यादा मायने रखता है, पर पूरा पेज URL सबसे सुरक्षित विकल्प है।

3. टोकन मांगें

import os
import requests

API_URL = "https://api.scarnox.com/api/tasks/create"
API_KEY = os.environ["SCARNOX_KEY"]

def solve_captcha(sitekey: str, page_url: str) -> str:
    r = requests.post(
        API_URL,
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={
            "captcha_type": "PopularCaptchaTaskProxyless",
            "site_key": sitekey,
            "site_url": page_url,
        },
        timeout=185,  # कॉल टोकन तैयार होने तक रुकती है
    )
    data = r.json()
    if data.get("errorId") != 0:
        raise RuntimeError(f"{data.get('errorCode')}: {data.get('errorDescription')}")
    return data["solution"]["token"]

if __name__ == "__main__":
    token = solve_captcha("10000000-ffff-ffff-ffff-000000000001", "https://example.com/signup")
    print(token[:40], "...")

बस इतना ही इंटीग्रेशन है। यहां कोई polling लूप नहीं है, और कोई दूसरी "परिणाम लाओ" कॉल भी नहीं। रिक्वेस्ट तब लौटती है जब टोकन तैयार हो, इसलिए एक ही सेटिंग मायने रखती है: इतना लंबा टाइमआउट जो धीमे सॉल्व को कवर करे। लगभग 185 सेकंड रखें।

सफल रिस्पॉन्स में errorId 0 होता है, और टोकन solution.token के अंदर होता है। कोई भी दूसरा errorId बताता है कि सॉल्व विफल हुआ, और रिस्पॉन्स में errorCode और errorDescription होते हैं जो कारण बताते हैं।

4. टोकन सबमिट करें

टोकन वहां जाता है जहां साइट कैप्चा रिस्पॉन्स की उम्मीद करती है। PopularCaptcha के लिए यह लगभग हमेशा h-captcha-response नाम का फॉर्म फ़ील्ड होता है। कई साइटें g-recaptcha-response भी स्वीकार करती हैं, इसलिए दोनों भेजें:

import requests

def sign_up(session: requests.Session, form_url: str, email: str, sitekey: str) -> requests.Response:
    token = solve_captcha(sitekey, form_url)
    return session.post(form_url, data={
        "email": email,
        "h-captcha-response": token,
        "g-recaptcha-response": token,
    }, timeout=30)

यहां दो बातें मायने रखती हैं। असली साइटें आम तौर पर पेज लोड की सेशन कुकीज़ भी जांचती हैं, इसलिए POST से पहले फॉर्म उसी requests.Session से लोड करें। और POST फॉर्म के action URL पर करें, जो हमेशा पेज URL नहीं होता।

सॉल्व सबमिट से ठीक पहले करें। टोकन लगभग दो मिनट में समाप्त होता है, इसलिए लंबे काम की शुरुआत में उसे मांगकर रखें नहीं। अगर साइट टोकन अस्वीकार करे, तो DevTools में फॉर्म खोलकर छिपे फ़ील्ड के नाम दोबारा जांचें।

5. विफलताएं संभालें

विफल सॉल्व मुफ्त हैं, इसलिए रिट्राई में केवल समय जाता है। पर कुछ एरर रिट्राई से कभी सफल नहीं होंगे, इसलिए अंधाधुंध लूप न करें। हर बार errorId जांचें, errorCode और errorDescription लॉग करें, और केवल अस्थायी विफलताओं को रिट्राई करें।

नेटवर्क एरर को अलग संभालना होता है, क्योंकि requests किसी रिस्पॉन्स के बनने से पहले ही एरर उठा देता है:

import requests

try:
    token = solve_captcha(sitekey, page_url)
except requests.RequestException as exc:
    print("network problem, retry later:", exc)
except RuntimeError as exc:
    print("solve rejected:", exc)

backoff और jitter वाली पूरी रिट्राई नीति एरर हैंडलिंग गाइड में है।

आम गलतियां

मुफ्त में आज़माएं

खाता बनाएं और मुफ्त ट्रायल क्रेडिट के साथ शुरू करें, कार्ड की ज़रूरत नहीं। बड़े काम में जोड़ने से पहले ऊपर का उदाहरण अपने फॉर्म पर चलाएं। बड़ी मात्रा में सॉल्व की लागत के लिए मौजूदा कीमतें देखें।

हर सॉल्व का लॉग

हर सॉल्व के लिए एक पंक्ति लॉग करें: sitekey, पेज का होस्ट, errorId, विफलता पर errorCode, और कॉल में लगा समय। API key या प्रॉक्सी पासवर्ड शामिल न करें। ये पंक्तियां बताती हैं कि धीमा रन पेज के कारण धीमा है, प्रॉक्सी के कारण, या सॉल्वर के कारण। सपोर्ट अनुरोध खोलने पर सबसे पहले यही चाहिए।

लूप में सॉल्व करना

अगर आपकी स्क्रिप्ट एक के बाद एक कई कैप्चा हल करती है, तो लूप सरल रखें। सॉल्व करें, सबमिट करें, नतीजा जांचें, और तभी आगे बढ़ें। पहले से सॉल्व करके टोकन कतार में न रखें, क्योंकि हर एक लगभग दो मिनट में समाप्त होता है। एक ही साइट पर सॉल्व के बीच थोड़ा विराम आपकी रिक्वेस्ट दर को उस दर के करीब रखता है जो एक इंसान बनाएगा।

अगले कदम