लैंगचेन में reCAPTCHA कैसे हल करें

reCAPTCHA वेब ब्राउज़िंग के दौरान AI एजेंट्स द्वारा सबसे अधिक मिलने वाला सत्यापन चुनौती है। LangChain एजेंट्स जो डेटा संग्रह, फॉर्म सबमिशन या बहु-चरणीय वर्कफ़्लो करते हैं, लॉगिन पेज, खोज परिणामों और सुरक्षित सामग्री पर reCAPTCHA v2 चेकबॉक्स और अदृश्य चुनौतियों का सामना करते हैं। इस पाठ्यदल में, CapSolver के capsolver-agent पैकेज का उपयोग करके LangChain में विशेष रूप से reCAPTCHA v2 को हल करने के तरीके को दर्शाया गया है, जिसमें Token मोड और Browser मोड के लिए पूर्ण कोड उदाहरण शामिल हैं।

TL;DR

• LangChain वेब एजेंट्स के लिए reCAPTCHA v2 सबसे आम रूप से मिलने वाला CAPTCHA प्रकार है
• CapSolver के LangChain उपकरण reCAPTCHA v2 (चेकबॉक्स और अदृश्य) को 5-12 सेकंड के औसत समय में हल करते हैं
• Token मोड के लिए केवल साइट कुंजी और URL की आवश्यकता होती है — कोई ब्राउज़र की आवश्यकता नहीं होती
• Browser मोड किसी भी पृष्ठ पर reCAPTCHA की स्वचालित रूप से पहचान करता है और टोकन को DOM में भर देता है
• capsolver-agent पैकेज LangChain के ReAct एजेंट्स के लिए मूल BaseTool कार्यान्वयन प्रदान करता है

reCAPTCHA LangChain एजेंट्स को क्यों ब्लॉक करता है

reCAPTCHA v2 मिलियनों वेबसाइटों पर लगाया जाता है ताकि मानव उपयोगकर्ताओं और स्वचालित ट्रैफिक के बीच अंतर किया जा सके। जब एक LangChain एजेंट एक सुरक्षित पृष्ठ पर जाता है — चाहे वह लीड एनरिचमेंट, डेटा निकालना या वर्कफ़्लो ऑटोमेशन के लिए हो — गूगल के जोखिम विश्लेषण इंजन सत्र का मूल्यांकन करता है। स्वचालित ब्राउज़र, हेडलेस परिवेश और तेज़ नेविगेशन पैटर्न reCAPTCHA चुनौती को ट्रिगर करते हैं, जो एजेंट के कार्यान्वयन को रोक देते हैं।

चुनौती दो रूपों में दिखाई देती है: दृश्य चेकबॉक्स ("मैं एक रोबोट नहीं हूं") जिसके लिए अंतरक्रिया की आवश्यकता होती है, और अदृश्य विकल्प जो जोखिम स्कोर के आधार पर चुपके से ट्रिगर होता है। दोनों रूपों में आगे बढ़ने के लिए एक वैध टोकन सबमिशन की आवश्यकता होती है। बिना हल करने के बिना, LangChain एजेंट अपने कार्य को आगे नहीं बढ़ा सकता है, और पूरा श्रृंखला विफल हो जाता है।

गूगल के reCAPTCHA दस्तावेज़ बताते हैं कि प्रणाली ब्राउज़र वातावरण जांच, अंतरक्रिया पैटर्न और ऐतिहासिक व्यवहार सहित उन्नत जोखिम विश्लेषण का उपयोग करती है। इस कारण से reCAPTCHA ऐसे स्वचालित एजेंट्स के लिए विशेष रूप से चुनौतिपूर्ण होता है जिनके पास मानव-जैसे ब्राउज़िंग पैटर्न नहीं होते।

CapSolver की AI-शक्ति वाली हल करने वाली सेवा reCAPTCHA v2 को अपने क्लाउड इंफ्रास्ट्रक्चर के माध्यम से वैध टोकन उत्पन्न करके हल करती है, जिससे एजेंट के संदर्भ में पिक्सेल-पर-पिक्सेल अंतरक्रिया या छवि स्वीकृति की आवश्यकता नहीं होती।

शुरू करने से पहले आपके पास क्या होना आवश्यक है

आवश्यक पैकेज स्थापित करें:

# मुख्य इंजन (आवश्यक निर्भरता)
pip install git+https://github.com/capsolver-ai/capsolver-core.git

# LangChain समर्थन के साथ एजेंट उपकरण
pip install "capsolver-agent[langchain] @ git+https://github.com/capsolver-ai/capsolver-agent.git"

# LangChain रनटाइम
pip install langchain-openai langgraph

पर्यावरण चर निर्धारित करें:

export CAPSOLVER_API_KEY="आपका-capsolver-api-key"
export OPENAI_API_KEY="आपका-openai-api-key"

आपके लक्ष्य पृष्ठ से reCAPTCHA साइट कुंजी भी आवश्यक है। CapSolver ब्राउज़र एक्सटेंशन का उपयोग करके इसे पहचानें, या पृष्ठ के स्रोत में data-sitekey विशेषताओं की जांच करें। reCAPTCHA पहचान गाइड विविध प्रकार के v2 चेकबॉक्स, v2 अदृश्य और v3 विकल्पों के बीच अंतर करने के बारे में बताता है।

चरण 1 — लक्ष्य पृष्ठ पर reCAPTCHA v2 पैरामीटर की पहचान करें

क्या करना है

अपने लक्ष्य पृष्ठ पर reCAPTCHA साइट कुंजी ढूंढें। ब्राउज़र डेवलपर टूल्स खोलें और पृष्ठ के स्रोत की खोज करें:

<!-- दृश्य reCAPTCHA v2 (चेकबॉक्स) -->
<div class="g-recaptcha" data-sitekey="6LeIxAcTAAAAAJcZVRqyHh71UMIEGNQ_MXjiZKhI"></div>

<!-- अदृश्य reCAPTCHA v2 -->
<div class="g-recaptcha" data-sitekey="6LeIxAcT..." data-size="invisible"></div>

तीन मान रिकॉर्ड करें: data-sitekey, पूर्ण पृष्ठ URL, और क्या यह दृश्य है या अदृश्य (जांचें कि data-size="invisible" है या नहीं)।

प्रोग्रामेटिक डिटेक्शन के लिए CapSolver SDK का उपयोग करके:

from capsolver_core import create_capsolver
from playwright.async_api import async_playwright

async def detect_recaptcha(url: str):
    cap = create_capsolver(api_key="YOUR_API_KEY")
    async with async_playwright() as p:
        browser = await p.chromium.launch()
        page = await browser.new_page()
        await page.goto(url)
        
        # पृष्ठ पर सभी CAPTCHAs की स्वचालित रूप से पहचान करें
        infos = await cap.get_captcha_info(page)
        for info in infos:
            print(f"प्रकार: {info.type}, कुंजी: {info.website_key}")
        
        await browser.close()
    await cap.aclose()

इसका क्यों महत्व है

साइट कुंजी reCAPTCHA हल करने के लिए आवश्यक पैरामीटर है। बिना इसके, हल करने वाली सेवा विशिष्ट साइट के लिए वैध टोकन उत्पन्न नहीं कर सकती। एक ही डोमेन पर अलग-अलग पृष्ठ अलग-अलग साइट कुंजी का उपयोग कर सकते हैं, इसलिए हर पृष्ठ के लिए जांच करें।

बचने के लिए सामान्य गलतियां

• उत्पादन में एक परीक्षण कुंजी का उपयोग करना: गूगल परीक्षण कुंजी (जैसे 6LeIxAcT...) प्रदान करता है जो हमेशा पास होता है। वास्तविक साइटें वास्तविक हल के आवश्यकता वाली अद्वितीय कुंजी का उपयोग करती हैं।
• v2 के साथ v3 को गलती से बराबर करना: reCAPTCHA v3 अलग टास्क प्रकार का उपयोग करता है और page_action की आवश्यकता होती है। स्क्रिप्ट स्रोत जांचें — v3 ?render=SITE_KEY के माध्यम से लोड होता है, जबकि div तत्व के बजाय।

चरण 2 — LangChain उपकरण के साथ reCAPTCHA v2 हल करें (Token मोड)

क्या करना है

LangChain उपकरण का उपयोग करके reCAPTCHA v2 को अपने एजेंट के कार्यप्रणाली में हल करें:

import asyncio
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent
from capsolver_agent.langchain import get_langchain_tools

async def solve_recaptcha_with_agent():
    # CapSolver LangChain उपकरण प्राप्त करें
    tools = get_langchain_tools(api_key="YOUR_CAPSOLVER_API_KEY")
    
    # ReAct एजेंट बनाएं
    llm = ChatOpenAI(model="gpt-4o", temperature=0)
    agent = create_react_agent(llm, tools=tools)
    
    # एजेंट को reCAPTCHA हल करने के लिए कहें
    result = await agent.ainvoke({
        "messages": [("user", 
            "https://example.com/login पर reCAPTCHA v2 हल करें। "
            "साइट कुंजी 6LeIxAcTAAAAAJcZVRqyHh71UMIEGNQ_MXjiZKhI है। "
            "मुझे फॉर्म सबमिट करने के लिए उपयोग कर सकने वाला टोकन लौटाएं।"
        )]
    })
    
    print(result["messages"][-1].content)

asyncio.run(solve_recaptcha_with_agent())

एजेंट लूप के बिना सीधे निष्पादन के लिए (जब आप प्रोग्रामेटिक नियंत्रण चाहते हैं):

from capsolver_agent.schema import create_executor

async def solve_recaptcha_direct():
    executor = create_executor(api_key="YOUR_CAPSOLVER_API_KEY")
    
    result = await executor.execute("solve_captcha", {
        "captcha_type": "reCaptchaV2",
        "website_url": "https://example.com/login",
        "website_key": "6LeIxAcTAAAAAJcZVRqyHh71UMIEGNQ_MXjiZKhI"
    })
    
    if result["success"]:
        token = result["solution"]["token"]
        print(f"reCAPTCHA हल कर दिया गया! टोकन: {token[:60]}...")
        # फॉर्म POST में 'g-recaptcha-response' के रूप में इस टोकन को सबमिट करें
        return token
    else:
        print(f"असफल: {result['error']}")
        return None

वापस किया गया टोकन फॉर्म POST अनुरोध में g-recaptcha-response के रूप में सबमिट किया जाना चाहिए। reCAPTCHA v2 हल करने के दस्तावेज़ टोकन सबमिशन पैटर्न के बारे में अतिरिक्त विवरण प्रदान करता है।

इसका क्यों महत्व है

टोकन मोड reCAPTCHA v2 के लिए सबसे तेज़ तरीका है — ब्राउज़र ओवरहेड के बिना औसत हल समय 5-12 सेकंड है। LangChain एजेंट्स के लिए जिन्हें लक्ष्य साइट के पैरामीटर पता हैं, इसके माध्यम से बिना ब्राउज़र इकाई लॉन्च किए CAPTCHA साफ करने की सुविधा प्रदान की जाती है।

बचने के लिए सामान्य गलतियां

• टोकन तेजी से सबमिट न करना: reCAPTCHA टोकन लगभग 120 सेकंड के बाद समाप्त हो जाता है। टोकन प्राप्त करने के बाद तुरंत फॉर्म सबमिट करें।
• अदृश्य फ्लैग छोड़ देना: अदृश्य reCAPTCHA v2 के लिए, हल करने का तरीका समान है, लेकिन आपको एम्बेडिंग के बाद फॉर्म सबमिशन कॉलबैक ट्रिगर करने की आवश्यकता हो सकती है।

चरण 3 — अदृश्य reCAPTCHA v2 का प्रबंधन करें

क्या करना है

अदृश्य reCAPTCHA v2 एपीआई पर एक ही तरह काम करता है — एक ही reCaptchaV2 टास्क प्रकार दोनों विकल्पों के लिए काम करता है:

# अदृश्य reCAPTCHA v2 — एक ही एपीआई कॉल
result = await executor.execute("solve_captcha", {
    "captcha_type": "reCaptchaV2",
    "website_url": "https://example.com/checkout",
    "website_key": "6Ld_SITE_KEY_HERE"
    # कोई अतिरिक्त फ्लैग की आवश्यकता नहीं है — CapSolver अदृश्य स्वचालित रूप से संभालता है
})

अंतर यह है कि आप टोकन को कैसे एम्बेड करते हैं। अदृश्य reCAPTCHA आमतौर पर बटन क्लिक या फॉर्म सबमिशन घटना से बांधा जाता है। टोकन प्राप्त करने के बाद, कॉलबैक ट्रिगर करें:

# हल करने के बाद Playwright/ब्राउज़र संदर्भ में:
await page.evaluate(f"""() => {{
    document.getElementById('g-recaptcha-response').innerHTML = '{token}';
    // बाउंड कॉलबैक खोजें
    if (typeof ___grecaptcha_cfg !== 'undefined') {{
        const clients = ___grecaptcha_cfg.clients;
        for (const key in clients) {{
            const client = clients[key];
            // कॉलबैक खोजें और कॉल करें
            if (client && client.L && client.L.L && client.L.L.callback) {{
                client.L.L.callback('{token}');
            }}
        }}
    }}
}}""")

reCAPTCHA कॉलबैक पहचान गाइड किसी भी साइट के लिए सही कॉलबैक फ़ंक्शन की पहचान करने के बारे में बताता है।

चरण 4 — स्वचालित reCAPTCHA पहचान और हल करने के लिए ब्राउज़र मोड का उपयोग करें

क्या करना है

जब आपका LangChain एजेंट ब्राउज़र चलाता है और डायनामिक रूप से reCAPTCHA का सामना करता है, तो solve_on_page() का उपयोग स्वचालित पहचान और भरने के लिए करें:

import asyncio
from capsolver_core import create_capsolver
from playwright.async_api import async_playwright

async def auto_solve_recaptcha(target_url: str):
    """किसी भी पृष्ठ पर reCAPTCHA की स्वचालित रूप से पहचान और हल करें।"""
    cap = create_capsolver(api_key="YOUR_CAPSOLVER_API_KEY")
    
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        page = await browser.new_page()
        await page.goto(target_url)
        await page.wait_for_load_state("networkidle")
        
        # एक कॉल सभी कार्यों को निपटाता है: पहचान → हल → भरना
        results = await cap.solve_on_page(page)
        
        for r in results:
            if r.solution:
                print(f"{r.info.type} हल कर दिया गया: token={r.solution.token[:50]}...")
                print(f"पृष्ठ में टोकन भरा गया: {r.filled}")
            else:
                print(f"{r.info.type} हल करने में असफल: {r.error}")
        
        # हल के बाद, पृष्ठ तैयार है — फॉर्म सबमिट करें
        submit_button = page.locator('button[type="submit"]')
        if await submit_button.count() > 0:
            await submit_button.click()
            await page.wait_for_navigation()
            print(f"फॉर्म सबमिट कर दिया गया। वर्तमान URL: {page.url}")
        
        await browser.close()
    await cap.aclose()

asyncio.run(auto_solve_recaptcha("https://example.com/login"))

ब्राउज़र मोड विशेष रूप से शक्तिशाली है क्योंकि यह लाइव DOM से reCAPTCHA पैरामीटर्स सीधे पढ़ता है — कोई हस्तचालित साइट कुंजी निकालने की आवश्यकता नहीं होती। सीडीएस एपीआई पहचानता है कि CAPTCHA प्रकार है, data-sitekey पढ़ता है, हल करता है और टोकन को स्वचालित रूप से g-recaptcha-response टेक्स्टएरिया में लिख देता है।

अपना बोनस कोड दावा करें: CapSolver डैशबोर्ड पर कोड WEBS का उपयोग करें ताकि प्रत्येक भरोसे पर 5% अतिरिक्त बोनस मिले। LangChain विकासकर्ता के लिए अद्वितीय है जो reCAPTCHA चुनौतियों के साथ एजेंट बनाते हैं।

चरण 5 — reCAPTCHA संसाधन के साथ एक उत्पादन LangChain एजेंट बनाएं

क्या करना है

reCAPTCHA हल करने के साथ अन्य उपकरणों के साथ संयोजन करके पूर्ण उत्पादन वर्कफ़्लो बनाएं:

import asyncio
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent
from capsolver_agent.langchain import get_langchain_tools

async def production_agent():
    capsolver_tools = get_langchain_tools(api_key="YOUR_CAPSOLVER_API_KEY")
    llm = ChatOpenAI(model="gpt-4o", temperature=0)
    agent = create_react_agent(llm, tools=capsolver_tools)
    
    # reCAPTCHA हल करने की आवश्यकता वाला बहु-चरणीय कार्य
    result = await agent.ainvoke({
        "messages": [("user",
            "मैं एक सुरक्षित संसाधन तक पहुंचना चाहता हूं। पहले, https://example.com/gate पर reCAPTCHA v2 हल करें "
            "(साइट कुंजी: 6LeIxAcTAAAAAJcZVRqyHh71UMIEGNQ_MXjiZKhI), "
            "फिर मुझे टोकन बताएं ताकि मैं अपने अनुरोध के साथ आगे बढ़ सकूं।"
        )]
    })
    
    return result["messages"][-1].content

asyncio.run(production_agent())

जिन एजेंट्स को विभिन्न साइटों पर कई reCAPTCHA संस्करणों के साथ निपटना होता है, उनके लिए एक ही उपकरण दोनों v2 और v3 के लिए काम करते हैं — केवल captcha_type पैरामीटर को reCaptchaV2 से reCaptchaV3 में बदलें।

CapSolver उत्पाद पृष्ठ सभी समर्थित CAPTCHA प्रकार और उनकी कीमतों की सूची प्रदान करता है, जो आपके LangChain एजेंट डेप्लॉयमेंट के लिए लागत का अनुमान लगाने में मदद करता है।

निष्कर्ष

LangChain में reCAPTCHA हल करने के लिए capsolver-agent पैकेज की आवश्यकता होती है, जिसमें LangChain के अतिरिक्त शामिल है, जो मूल BaseTool कार्यान्वयन प्रदान करता है। Token मोड के लिए ब्राउज़र की आवश्यकता नहीं होती और ज्ञात साइट कुंजी के साथ 5-12 सेकंड में काम करता है, जबकि Browser मोड किसी भी पृष्ठ पर reCAPTCHA टोकन की स्वचालित रूप से पहचान और भरना करता है। CapSolver AI हल करने वाली बुनियादी सुविधा को बल देता है, v2 चेकबॉक्स और अदृश्य विकल्पों के लिए एक एकीकृत इंटरफ़ेस के माध्यम से।

अपने लक्ष्य पृष्ठ पर साइट कुंजी की पहचान करें, फिर get_langchain_tools() को अपने ReAct एजेंट में एम्बेड करें। एजेंट के तर्क लूप बिना किसी अनुमति के तब तक reCAPTCHA हल करने का निर्णय लेता है जब तक कि सत्यापन हासिल नहीं हो जाता।

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

CapSolver के साथ reCAPTCHA v2 के हल करने की सफलता दर क्या है?

CapSolver के पास reCAPTCHA v2 चुनौतियों के लिए 95-99% सफलता दर है। AI-शक्ति वाली हल करने वाली सेवा चेकबॉक्स और अदृश्य विकल्प दोनों के लिए काम करती है। विफल प्रयासों के लिए शुल्क नहीं लिया जाता है, और संरचित त्रुटि उत्तर आपके एजेंट को स्वचालित रूप से पुनः प्रयास करने की अनुमति देता है।

reCAPTCHA v2 के हल करने में कितना समय लगता है?

reCAPTCHA v2 के हल करने में औसत समय 5-12 सेकंड होता है। इसमें CapSolver की सेवा तक नेटवर्क राउंड-ट्रिप समय और AI अंतर्दृष्टि प्रक्रिया शामिल होती है। समय-संवेदनशील वर्कफ़्लो के लिए, SDK नियंत्रित समय सीमा और पॉलिंग अंतराल के समर्थन के साथ आता है।

क्या LangChain उपकरण reCAPTCHA एंटरप्राइज हैंडल कर सकता है?

हां। enterprise: true के साथ पैरामीटर पास करें जब आप solve_captcha कॉल करते हैं। reCAPTCHA एंटरप्राइज वी2/वी3 टास्क प्रकार का उपयोग करता है लेकिन कुछ अतिरिक्त पैरामीटर जैसे s टोकन की आवश्यकता हो सकती है। CapSolver सेवा एंटरप्राइज विकल्पों के साथ स्वचालित रूप से काम करती है।

क्या LangChain में reCAPTCHA हल करने के लिए ब्राउज़र की आवश्यकता होती है?

नहीं। टोकन मोड किसी भी ब्राउजर के बिना काम करता है — आप साइट कुंजी और URL प्रदान करते हैं, और टोकन वापस प्राप्त करते हैं। ब्राउजर मोड (प्लेयराइट की आवश्यकता होती है) वैकल्पिक है और जब आप लाइव पृष्ठों पर स्वचालित डिटेक्शन और भरने के लिए उपयोग करना चाहते हैं तो इसका उपयोग किया जाता है। अधिकांश LangChain एकीकरण आसानी और गति के लिए टोकन मोड का उपयोग करते हैं।

मैं reCAPTCHA टोकन समाप्त होने के साथ कैसे निपटूं?

reCAPTCHA टोकन लगभग 120 सेकंड के बाद समाप्त हो जाते हैं। फॉर्म सबमिशन के निकटतम टोकन के लिए अनुरोध करें। अगर आपके कार्य प्रवाह में समाधान और सबमिशन के बीच देरी है, तो पाइपलाइन के शुरू में समाधान के बजाय "सबमिट के ठीक पहले समाधान" पैटर्न कार्यान्वित करें।