Mar17, 2026

CAPTCHA हल करने का तरीका – TinyFish AgentQL के साथ चरण-दर-चरण गाइड CapSolver का उपयोग करके

Rajinder Singh

Deep Learning Researcher

जब आपके AI-संचालित वेब ऑटोमेशन के सामने CAPTCHA की दीवार हो जाती है, तो पूरा पाइपलाइन रुक जाता है। पेज लोड नहीं होते, फॉर्म जमा नहीं किए जा सकते, और डेटा निकालना रुक जाता है — सभी बॉट्स को अवरुद्ध करने के लिए बनाए गए चुनौती के कारण। TinyFish AgentQL एक शक्तिशाली टूल सूट है जो AI को वेब से जोड़ने के लिए बनाई गई है, जिसमें प्राकृतिक भाषा के प्रश्न, Playwright एकीकरण और व्यावसायिक पैमाने पर संरचित डेटा निकालना शामिल है। लेकिन किसी भी ब्राउजर ऑटोमेशन फ्रेमवर्क की तरह, यह CAPTCHAs पर फंस जाता है।

CapSolver इसे पूरी तरह से बदल देता है। AgentQL के Playwright-संचालित ब्राउजर सत्र में CapSolver Chrome एक्सटेंशन लोड करके, CAPTCHAs को पृष्ठभूमि में स्वचालित रूप से और अदृश्य रूप से हल कर दिया जाता है। कोई हस्तक्षेप आवश्यक नहीं है। आपके अंत में कोई जटिल API ऑर्केस्ट्रेशन नहीं है। आपके ऑटोमेशन स्क्रिप्ट उसी तरह चलते रहते हैं जैसे कि CAPTCHA कभी नहीं था।

सबसे अच्छी बात? आपके AgentQL प्रश्न और स्क्रिप्ट में केवल एक लाइन भी CAPTCHA-संबंधी कोड की आवश्यकता नहीं होती है। एक्सटेंशन अपने आप डिटेक्शन, हल करना और टोकन इंजेक्शन करता है जबकि आपका एजेंट अपने सबसे अच्छे काम — डेटा निकालना और कार्य प्रवाह के ऑटोमेशन में ध्यान केंद्रित करता है।

TinyFish AgentQL क्या है?

TinyFish AgentQL एक व्यावसायिक गुणवत्ता वाला टूलकिट है जो AI एजेंट और LLMs को जीवंत वेब परिवेश से जोड़ने के लिए बनाया गया है। TinyFish द्वारा विकसित, यह एक AI-संचालित प्रश्न भाषा प्रदान करता है जो पृष्ठ तत्वों की स्थिति और प्राकृतिक भाषा के उपयोग से संरचित डेटा निकालने की अनुमति देता है — कोई भी टूटे हुए CSS सेलेक्टर या XPaths की आवश्यकता नहीं होती है।

मुख्य विशेषताएं

AI-संचालित प्रश्न भाषा: पृष्ठ सामग्री के आधार पर तत्वों को सुगमता से खोजें। प्रश्न समय के साथ UI परिवर्तनों के साथ स्वयं ठीक हो जाते हैं।
Playwright एकीकरण: उन्नत ब्राउजर ऑटोमेशन के लिए पायथन और जावास्क्रिप्ट SDKs के साथ बिना किसी अंतर के एकीकृत।
संरचित डेटा निकालना: आउटपुट आकृति परिभाषित करें और किसी भी पृष्ठ से साफ, संरचित डेटा प्राप्त करें — सार्वजनिक या निजी, स्थिर या डायनामिक।
REST API: REST एंडपॉइंट के माध्यम से SDKs के बिना प्रश्न चलाएं।
ब्राउजर डिबगर: वास्तविक समय में प्रश्नों के परीक्षण और सुधार के लिए एक Chrome एक्सटेंशन।
क्रॉस-साइट प्रतिरोध: समान वेबसाइटों पर संशोधन के बिना काम करता है, पृष्ठ परिवर्तनों के साथ स्वचालित रूप से अनुकूलित हो जाता है।
व्यावसायिक पैमाना: उच्च-प्रवाह कार्यभार के लिए बनाया गया, समानांतर में सैकड़ों कार्य चलाता है।

AgentQL किसी भी पृष्ठ पर काम करता है — संवेदनशील सामग्री और डायनामिक रूप से बनाए गए पृष्ठ शामिल हैं — बड़े पैमाने पर वेब ऑटोमेशन, डेटा संग्रह और AI एजेंट कार्य प्रवाह के लिए आदर्श है।

CapSolver क्या है?

CapSolver एक अग्रणी AI-संचालित CAPTCHA हल करने की सेवा है जो विविध CAPTCHA चुनौतियों को स्वचालित रूप से हल करती है। तेज उत्तर समय और व्यापक संगतता के साथ, CapSolver स्वचालित कार्य प्रवाह में बिना किसी अंतर के एकीकृत हो जाता है।

समर्थित CAPTCHA प्रकार

reCAPTCHA v2 (चेकबॉक्स और अदृश्य)
reCAPTCHA v3 & v3 एंटरप्राइज
Cloudflare Turnstile
Cloudflare 5-सेकंड चुनौती
AWS WAF CAPTCHA
अधिक

इस एकीकरण के अलग होने के कारण

अधिकांश CAPTCHA-हल करने वाले एकीकरण में आपको बॉयलरप्लेट कोड लिखने की आवश्यकता होती है: कार्य बनाएं, परिणामों की जांच करें, छिपे हुए फील्ड में टोकन डालें। यह रूपरेखा अपने खुद के Playwright या Puppeteer स्क्रिप्ट के साथ है।

AgentQL + CapSolver एक आधुनिक अलग दृष्टिकोण अपनाता है:

पारंपरिक (कोड-आधारित)	AgentQL + CapSolver एक्सटेंशन
CapSolver सेवा वर्ग लिखें	Playwright सत्र में एक्सटेंशन लोड करें
`createTask()` / `getTaskResult()` कॉल करें	एक्सटेंशन सब कुछ स्वयं हल करता है
`page.evaluate()` के माध्यम से टोकन डालें	टोकन इंजेक्शन अदृश्य है
कोड में त्रुटि, पुनर्प्रयास, समय सीमा का उपचार करें	एक्सटेंशन आंतरिक रूप से पुनर्प्रयास प्रबंधित करता है
प्रत्येक CAPTCHA प्रकार के लिए अलग कोड	सभी प्रकार के लिए स्वचालित रूप से काम करता है

मुख्य अवधारणा: CapSolver एक्सटेंशन AgentQL के Playwright ब्राउजर सत्र में चलता है। जब AgentQL किसी CAPTCHA वाले पृष्ठ पर जाता है, तो एक्सटेंशन इसे पहचानता है, पृष्ठभूमि में हल करता है और टोकन इंजेक्ट करता है — आपके स्क्रिप्ट के रूप में अंतरक्रिया करने से पहले। आपके ऑटोमेशन कोड साफ, ध्यान केंद्रित और CAPTCHA-मुक्त रहता है।

पूर्व शर्तें

एकीकरण सेटअप करने से पहले, सुनिश्चित करें कि आपके पास हैं:

TinyFish AgentQL स्थापित (पायथन SDK या जावास्क्रिप्ट SDK)
CapSolver खाता जिसमें API कुंजी हो ( यहां साइन अप करें )
Node.js 16+ और Python 3.8+ (आपके SDK चयन के आधार पर)
Playwright इंस्टॉल किया गया है और Chromium सहित

महत्वपूर्ण: Chrome एक्सटेंशन केवल Chromium में काम करते हैं जिसमें स्थायी सत्र होता है। यह Playwright की आवश्यकता है, न कि AgentQL की सीमा।

चरण-दर-चरण सेटअप

चरण 1: AgentQL स्थापित करें

पायथन SDK:

bash Copy

pip install agentql
playwright install chromium

जावास्क्रिप्ट SDK:

bash Copy

npm install agentql
npx playwright install chromium

चरण 2: CapSolver Chrome एक्सटेंशन डाउनलोड करें

CapSolver Chrome एक्सटेंशन डाउनलोड करें और एक विशेष निर्देशिका में निकालें:

CapSolver Chrome एक्सटेंशन v1.17.0 रिलीज पर जाएं
CapSolver.Browser.Extension-chrome-v1.17.0.zip डाउनलोड करें
जिप को निकालें:

bash Copy

mkdir -p ~/capsolver-extension
unzip CapSolver.Browser.Extension-chrome-v*.zip -d ~/capsolver-extension/

निकालने के काम करने की पुष्टि करें:

bash Copy

ls ~/capsolver-extension/manifest.json

आपको manifest.json दिखाई देगा — इससे पता चलता है कि एक्सटेंशन सही जगह पर है।

चरण 3: अपना CapSolver API कुंजी सेट करें

~/capsolver-extension/assets/config.js पर एक्सटेंशन कॉन्फिग फ़ाइल खोलें और apiKey मान को अपने से बदल दें:

javascript Copy

export const defaultConfig = {
  apiKey: 'CAP-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX', // ← आपका कुंजी यहां है
  useCapsolver: true,
  // ... अन्य कॉन्फिग
};

आप अपनी API कुंजी के लिए अपने CapSolver डैशबोर्ड से प्राप्त कर सकते हैं।

चरण 4: CapSolver एक्सटेंशन के साथ AgentQL शुरू करें

महत्वपूर्ण कदम यह है कि Playwright के Chromium को एक स्थायी सत्र के साथ शुरू करें जो CapSolver एक्सटेंशन लोड करता है।

पायथन उदाहरण:

python Copy

import agentql
from playwright.sync_api import sync_playwright
import time
import os

# CapSolver एक्सटेंशन का पथ
CAPSOLVER_EXTENSION_PATH = os.path.expanduser("~/capsolver-extension")

def main():
    with sync_playwright() as p:
        # Chromium को स्थायी सत्र और CapSolver एक्सटेंशन के साथ शुरू करें
        context = p.chromium.launch_persistent_context(
            user_data_dir="./browser-data",
            headless=False,  # एक्सटेंशन के लिए हेडलेस मोड आवश्यक नहीं है
            args=[
                f"--disable-extensions-except={CAPSOLVER_EXTENSION_PATH}",
                f"--load-extension={CAPSOLVER_EXTENSION_PATH}",
            ],
        )

        # AgentQL के साथ पेज को लपेटें जिससे AI-संचालित प्रश्न हो सके
        page = agentql.wrap(context.pages[0])

        # अपने लक्ष्य पृष्ठ पर जाएं
        page.goto("https://example.com/protected-page")

        # CapSolver के द्वारा किसी भी CAPTCHA के पता लगाने और हल करने के लिए प्रतीक्षा करें
        time.sleep(30)

        # AgentQL के प्राकृतिक भाषा प्रश्नों के साथ सबमिट बटन खोजें
        response = page.query_elements("""
        {
            submit_button
        }
        """)

        # सबमिट बटन क्लिक करें — CAPTCHA पहले से ही हल कर दिया गया है!
        response.submit_button.click()

        # सबमिशन के बाद डेटा निकालें
        result = page.query_data("""
        {
            confirmation_message
        }
        """)

        print(f"परिणाम: {result['confirmation_message']}")

        context.close()

if __name__ == "__main__":
    main()

जावास्क्रिप्ट उदाहरण:

javascript Copy

const { chromium } = require('playwright');
const agentql = require('agentql');
const path = require('path');
const os = require('os');

const CAPSOLVER_EXTENSION_PATH = path.join(os.homedir(), 'capsolver-extension');

(async () => {
  // Chromium को स्थायी सत्र और CapSolver एक्सटेंशन के साथ शुरू करें
  const context = await chromium.launchPersistentContext('./browser-data', {
    headless: false, // एक्सटेंशन के लिए हेडलेस मोड आवश्यक नहीं है
    args: [
      `--disable-extensions-except=${CAPSOLVER_EXTENSION_PATH}`,
      `--load-extension=${CAPSOLVER_EXTENSION_PATH}`,
    ],
  });

  // पहला पृष्ठ प्राप्त करें और AgentQL के साथ लपेटें
  const page = agentql.wrap(context.pages()[0]);

  // लक्ष्य पृष्ठ पर जाएं
  await page.goto('https://example.com/protected-page');

  // CapSolver के द्वारा किसी भी CAPTCHA के हल करने के लिए प्रतीक्षा करें
  await page.waitForTimeout(30000);

  // AgentQL प्रश्नों का उपयोग करके अंतरक्रिया करें — CAPTCHA पहले से ही हल कर दिया गया है
  const response = await page.queryElements(`{
    submit_button
  }`);

  await response.submit_button.click();

  // परिणाम डेटा निकालें
  const result = await page.queryData(`{
    confirmation_message
  }`);

  console.log('परिणाम:', result.confirmation_message);

  await context.close();
})();

चरण 5: एक्सटेंशन लोड हो रहा है या नहीं इसकी जांच करें

ब्राउजर शुरू करने के बाद, आप chrome://extensions में ब्राउजर विंडो में जाकर जांच सकते हैं कि CapSolver एक्सटेंशन सक्रिय है या नहीं। आपको CapSolver एक्सटेंशन सूचीबद्ध और सक्रिय दिखाई देना चाहिए।

अन्यथा, ब्राउजर कंसोल में CapSolver लॉग संदेशों की जांच करें जो सेविस वर्कर चल रहा है।

इसका उपयोग कैसे करें

सेटअप पूरा होने के बाद, CapSolver के साथ AgentQL का उपयोग आसान है।

स्वर्ण नियम

CAPTCHA-संबंधी कोड न लिखें। केवल CAPTCHA-सुरक्षित फॉर्म के साथ अंतरक्रिया करने से पहले एक अंतराल समय जोड़ें, और एक्सटेंशन को अपना काम करने दें।

उदाहरण 1: reCAPTCHA के पीछे फॉर्म जमा करें

python Copy

page.goto("https://example.com/contact")

# AgentQL प्रश्नों के साथ फॉर्म भरें
response = page.query_elements("""
{
    contact_form {
        name_field
        email_field
        message_field
        submit_button
    }
}
""")

response.contact_form.name_field.fill("John Doe")
response.contact_form.email_field.fill("john@example.com")
response.contact_form.message_field.fill("Hello, I have a question about your services.")

# CapSolver के द्वारा CAPTCHA हल करने के लिए प्रतीक्षा करें
time.sleep(30)

# सबमिट करें — CAPTCHA टोकन पहले से ही इंजेक्ट कर दिया गया है
response.contact_form.submit_button.click()

उदाहरण 2: Cloudflare Turnstile के साथ लॉगिन पृष्ठ

python Copy

page.goto("https://example.com/login")

# CapSolver के द्वारा Turnstile चुनौती हल करने के लिए प्रतीक्षा करें
time.sleep(25)

# AgentQL के साथ लॉगिन फॉर्म तत्वों की खोज करें
response = page.query_elements("""
{
    login_form {
        email_input
        password_input
        login_button
    }
}
""")

# फॉर्म भरें — Turnstile पहले से ही निपटा दिया गया है
response.login_form.email_input.fill("me@example.com")
response.login_form.password_input.fill("mypassword123")

# लॉगिन क्लिक करें
response.login_form.login_button.click()

उदाहरण 3: सुरक्षित पृष्ठों से डेटा निकालें

python Copy

page.goto("https://example.com/data")

# किसी भी CAPTCHA चुनौती के खत्म होने के लिए प्रतीक्षा करें
time.sleep(30)

# AgentQL के साथ संरचित डेटा निकालें
data = page.query_data("""
{
    products[] {
        name
        price
        rating
        availability
    }
}
""")

for product in data['products']:
    print(f"{product['name']}: ${product['price']} ({product['rating']} स्टार)")

सुझाए गए प्रतीक्षा समय

CAPTCHA प्रकार	आमतौर पर हल करने में समय	सुझाए गए प्रतीक्षा
reCAPTCHA v2 (चेकबॉक्स)	5-15 सेकंड	30-60 सेकंड
reCAPTCHA v2 (अदृश्य)	5-15 सेकंड	30 सेकंड
reCAPTCHA v3	3-10 सेकंड	20-30 सेकंड
Cloudflare Turnstile	3-10 सेकंड	20-30 सेकंड

टिप्पणी: संदेह होने पर 30 सेकंड का उपयोग करें। ज्यादा समय लेना बेहतर है जब आप जल्दी से जमा करने की कोशिश करते हैं। अतिरिक्त समय परिणाम पर प्रभाव नहीं डालता है।

पृष्ठभूमि में कैसे काम करता है

जब AgentQL के साथ CapSolver एक्सटेंशन लोड होता है, तो निम्नलिखित होता है:

Copy

आपका AgentQL स्क्रिप्ट
───────────────────────────────────────────────────
page.goto("https://...")       ──► Chromium पृष्ठ लोड करता है
                                           │
                                           ▼
                               ┌─────────────────────────────┐
                               │  CAPTCHA विजेट वाला पृष्ठ     │
                               │                               │
                               │  CapSolver एक्सटेंशन:         │
                               │  1. कॉन्टेंट स्क्रिप्ट CAPTCHA पृष्ठ पर पता लगाता है │
                               │  2. सेविस वर्कर CapSolver API कॉल करता है │
                               │  3. टोकन प्राप्त होता है            │
                               │  4. टोकन छिपे फॉर्म फील्ड में इंजेक्ट किया जाता है │
                               └─────────────────────────────┘
                                           │
                                           ▼
time.sleep(30)                   एक्सटेंशन CAPTCHA हल करता है...
                                           │
                                           ▼
page.query_elements(...)         AgentQL फॉर्म तत्व खोजता है
submit_button.click()            फॉर्म साथ वैध टोकन के साथ जमा होता है
                                           │
                                           ▼
                               "सत्यापन सफल!"

एक्सटेंशन कैसे लोड होता है

जब Playwright Chromium के साथ --load-extension फ्लैग के साथ शुरू होता है:

Chromium के साथ CapSolver एक्सटेंशन लोड होता है
एक्सटेंशन सक्रिय होता है — इसका सेविस वर्कर शुरू होता है और सभी पृष्ठों में कॉन्टेंट स्क्रिप्ट इंजेक्ट करता है
CAPTCHA वाले पृष्ठों पर — कॉन्टेंट स्क्रिप्ट पृष्ठ पर विजेट की पहचान करता है, CapSolver API कॉल करता है, और समाधान टोकन पृष्ठ में इंजेक्ट करता है
AgentQL सामान्य रूप से काम करता है — प्रश्न, क्लिक और डेटा निकालना सामान्य रूप से काम करता है, CAPTCHA पहले से ही निपटा दिया गया है

पूर्ण विन्यास संदर्भ

यहां AgentQL + CapSolver एकीकरण के लिए सभी विन्यास विकल्पों के साथ एक पूर्ण Python सेटअप है:

python Copy

import agentql
from playwright.sync_api import sync_playwright
import os

# विन्यास
CAPSOLVER_EXTENSION_PATH = os.path.expanduser("~/capsolver-extension")
USER_DATA_DIR = "./browser-data"

with sync_playwright() as p:
    context = p.chromium.launch_persistent_context(
        user_data_dir=USER_DATA_DIR,
        headless=False,
        args=[
            f"--disable-extensions-except={CAPSOLVER_EXTENSION_PATH}",
            f"--load-extension={CAPSOLVER_EXTENSION_PATH}",
        ],
    )
    page = agentql.wrap(context.pages[0])
    # ... आपके ऑटोमेशन कोड यहां है
    context.close()

विन्यास विकल्प

विकल्प	विवरण
`user_data_dir`	ब्राउजर प्रोफ़ाइल डेटा (कुकीज, सत्र) संग्रहित करने के लिए निर्देशिका। स्थायी सत्र के लिए आवश्यक है।
`headless`	आवश्यक है `False` — Chrome एक्सटेंशन हेडलेस मोड में काम नहीं करते।
`--disable-extensions-except`	कौन से एक्सटेंशन लोड हो सकते हैं (संघर्ष रोकने के लिए)।
`--load-extension`	अनपैक किए गए कैपसॉल्वर एक्सटेंशन डिरेक्टरी का पथ।
`CAPSOLVER_EXTENSION_PATH`	`manifest.json` के साथ निकाले गए कैपसॉल्वर एक्सटेंशन का पूर्ण पथ।

कैपसॉल्वर API कुंजी को सीधे एक्सटेंशन के assets/config.js फाइल में कॉन्फिगर किया जाता है (ऊपर दिए गए चरण 3 देखें)।

कैपसॉल्वर का उपयोग टिनीफिश ब्राउजर के साथ

ऊपर दिए गए सभी चरणों में यह माना जाता है कि आप स्वयं क्रोमियम को चला रहे हैं, स्थायी प्लेयराइट संदर्भ के साथ लोकल रूप से, ताकि कैपसॉल्वर एक्सटेंशन को लोड किया जा सके। लेकिन हर सेटअप आपको इस प्रकार के नियंत्रण की अनुमति नहीं देता है - यदि आपके ऑटोमेशन के लिए टिनीफिश ब्राउजर का उपयोग कर रहे हैं, जो टिनीफिश के द्वारा दिया गया रिमोट, ऑन-डिमांड ब्राउजर सेशन सेवा है, तो आप सीधे क्रोमियम प्रक्रिया के साथ नहीं नियंत्रित करते हैं, इसलिए आप इसी तरह एक्सटेंशन को लोड नहीं कर सकते हैं।

इस परिदृश्य में, कैपसॉल्वर को इसके API के माध्यम से एकत्र किया जा सकता है, सीधे अपने स्क्रिप्ट में: आप टिनीफिश ब्राउजर से रिमोट ब्राउजर सेशन के लिए अनुरोध करते हैं, प्लेयराइट के साथ CDP के माध्यम से जुड़ते हैं, कैपसॉल्वर SDK के साथ कैपचा हल करते हैं, और आप स्वयं पृष्ठ में परिणामी टोकन को एंग्रेट करते हैं। यह अधिक "पारंपरिक", कोड-आधारित दृष्टिकोण है जिसका उल्लेख इस लेख में पहले किया गया है - लेकिन जब एक्सटेंशन को आपके द्वारा नियंत्रित ब्राउजर इंस्टेंस में लोड नहीं किया जा सकता है, तो यह सही उपकरण है।

शुरू करने से पहले, कैपसॉल्वर SDK स्थापित करें:

bash Copy

pip install capsolver

निम्नलिखित कोड टिनीफिश ब्राउजर सत्र में एक reCAPTCHA हल करने के लिए कैपसॉल्वर के उपयोग को दर्शाता है:

python Copy

import time
import requests
import capsolver
from playwright.sync_api import sync_playwright


TINYFISH_API_KEY = "आपका टिनीफिश API कुंजी"
capsolver.api_key = "आपका कैपसॉल्वर API कुंजी"


website_url = "https://www.google.com/recaptcha/api2/demo"
website_key = "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
captcha_type = "ReCaptchaV2TaskProxyLess"


def create_tinyfish_browser(url):
    resp = requests.post(
        "https://api.browser.tinyfish.ai",
        headers={
            "X-API-Key": TINYFISH_API_KEY,
            "Content-Type": "application/json",
        },
        json={
            "url": url,
            "timeout_seconds": 300,
        },
        timeout=90,
    )
    resp.raise_for_status()
    return resp.json()


def close_tinyfish_browser(session_id):
    try:
        requests.delete(
            f"https://api.browser.tinyfish.ai/{session_id}",
            headers={"X-API-Key": TINYFISH_API_KEY},
            timeout=30,
        )
    except Exception as exc:
        print("   टिनीफिश ब्राउजर सत्र बंद करने में विफल: ", repr(exc))


def solve_recaptcha_v2():
    print("3. कैपसॉल्वर के साथ reCAPTCHA हल कर रहे हैं")
    solution = capsolver.solve({
        "type": captcha_type,
        "websiteURL": website_url,
        "websiteKey": website_key,
    })

    token = solution.get("gRecaptchaResponse")
    if not token:
        raise RuntimeError(f"कैपसॉल्वर एक reCAPTCHA टोकन नहीं लौटाया: {solution}")

    print("   कैपसॉल्वर कार्य समाप्त: ", token)
    return token


def inject_recaptcha_token(page, token):
    page.evaluate(
        """
        (token) => {
            const textarea = document.getElementById('g-recaptcha-response');
            if (textarea) {
                textarea.value = token;
            }
        }
        """,
        token,
    )
    print("   कैपसॉल्वर टोकन एंग्रेट कर दिया गया")
    page.click('input[type="submit"]')
    print("   सबमिट बटन क्लिक किया")


def main():
    session_id = None
    try:
        print("1. टिनीफिश ब्राउजर सत्र बना रहे हैं")
        session = create_tinyfish_browser(website_url)

        session_id = session["session_id"]
        cdp_url = session["cdp_url"]
        print("   टिनीफिश सत्र आईडी: ", session_id)
        print("   टिनीफिश cdp यूआरएल: ", cdp_url)

        with sync_playwright() as p:
            print("2. cdp के माध्यम से टिनीफिश ब्राउजर से जुड़ रहे हैं")
            browser = p.chromium.connect_over_cdp(cdp_url)
            context = browser.contexts[0]
            page = context.pages[0] if context.pages else context.new_page()
            page.wait_for_load_state("domcontentloaded", timeout=60000)
            print("   वर्तमान पृष्ठ यूआरएल: ", page.url)

            token = solve_recaptcha_v2()

            print("4. कैपसॉल्वर टोकन एंग्रेट कर रहे हैं")
            inject_recaptcha_token(page, token)

            page.wait_for_load_state("domcontentloaded", timeout=30000)
            time.sleep(3)

            body_text = page.locator("body").inner_text(timeout=10000)
            print("5. पृष्ठ परिणाम: ", " ".join(body_text.split()))

            print("6. ब्राउजर सत्र बंद कर रहे हैं")
            browser.close()
    finally:
        if session_id:
            close_tinyfish_browser(session_id)


if __name__ == "__main__":
    main()

आपके सेटअप के अनुरूप कौन सा दृष्टिकोण उपयुक्त है - स्थानीय, स्थायी प्लेयराइट संदर्भ में कैपसॉल्वर एक्सटेंशन लोड करना, या रिमोट टिनीफिश ब्राउजर सत्र के साथ कैपसॉल्वर API को सीधे कॉल करना - लक्ष्य एक ही है: आपके एजेंटक्यूएल ऑटोमेशन को अपने आप कैपचा-हैंडलिंग लॉजिक की आवश्यकता नहीं होगी।

समस्या निवारण

एक्सटेंशन लोड नहीं हो रहा है

लक्षण: कैपचा स्वचालित रूप से हल नहीं हो रहे हैं।

कारण: आप स्थायी संदर्भ के बजाय एक सामान्य ब्राउजर संदर्भ का उपयोग कर रहे हैं, या हेडलेस मोड में चल रहे हैं।

समाधान: प्लेयराइट में एक्सटेंशन आवश्यक हैं एक स्थायी संदर्भ और हेडेड मोड:

python Copy

# ✅ सही - स्थायी संदर्भ, हेडेड
context = p.chromium.launch_persistent_context(
    user_data_dir="./browser-data",
    headless=False,
    args=[...extension args...]
)

# ❌ गलत - सामान्य संदर्भ (एक्सटेंशन लोड नहीं होगा)
browser = p.chromium.launch()
context = browser.new_context()

कैपचा हल नहीं हो रहा है (फॉर्म विफल)

संभावित कारण:

अपर्याप्त वाइट समय - 60 सेकंड तक बढ़ाएं
अमान्य API कुंजी - अपने कैपसॉल्वर डैशबोर्ड की जांच करें
अपर्याप्त बैलेंस - अपने कैपसॉल्वर खाते को टॉप अप करें
एक्सटेंशन लोड नहीं हो रहा है - ऊपर "एक्सटेंशन लोड नहीं हो रहा है" देखें

हेडलेस मोड समर्थित नहीं है

लक्षण: स्क्रिप्ट चल रही है लेकिन कोई एक्सटेंशन दिखाई नहीं दे रहा है।

कारण: क्रोम एक्सटेंशन हेडलेस मोड में काम नहीं करते हैं।

समाधान: सर्वर पर एक वर्चुअल डिस्प्ले के साथ हेडेड मोड का उपयोग करें:

bash Copy

# Xvfb स्थापित करें
sudo apt-get install xvfb

# एक वर्चुअल डिस्प्ले शुरू करें
Xvfb :99 -screen 0 1280x720x24 &

# DISPLAY सेट करें
export DISPLAY=:99

गूगल क्रोम 137+ संगतता

लक्षण: एक्सटेंशन फ्लैग को चुपके से अनदेखा कर दिया गया है।

कारण: गूगल क्रोम 137+ ब्रांडेड बिल्ड में --load-extension का समर्थन बंद कर दिया गया है।

समाधान: प्लेयराइट के साथ बंडल क्रोमियम का उपयोग करें (सिफारिश किया गया है) या क्रोम फॉर टेस्टिंग का उपयोग करें:

bash Copy

# प्लेयराइट के क्रोमियम का उपयोग करें (सिफारिश किया गया है)
npx playwright install chromium

# या क्रोम फॉर टेस्टिंग डाउनलोड करें
# जाएं: https://googlechromelabs.github.io/chrome-for-testing/

शीर्ष अभ्यास

हमेशा बड़े वाइट समय का उपयोग करें। अधिक वाइट समय हमेशा सुरक्षित है। कैपचा आमतौर पर 5-20 सेकंड में हल हो जाता है, लेकिन नेटवर्क लेटेंसी, जटिल चुनौतियां, या पुनर्प्रयास अतिरिक्त समय जोड़ सकते हैं। 30-60 सेकंड एक अच्छा बिंदु है।
अपने ऑटोमेशन स्क्रिप्ट को स्पष्ट रखें। अपने एजेंटक्यूएल प्रश्नों में कैपचा-विशिष्ट लॉजिक न जोड़ें। एक्सटेंशन सब कुछ हल करता है - आपके कोड केवल डेटा निकालने और अंतरक्रिया पर केंद्रित होना चाहिए।
अपने कैपसॉल्वर बैलेंस की नियमित रूप से जांच करें। प्रत्येक कैपचा समाधान क्रेडिट के लायक होता है। अपने बैलेंस की जांच करें capsolver.com/dashboard अक्सर बाधाओं से बचने के लिए।
हमेशा स्थायी संदर्भ का उपयोग करें। जब आपको एक्सटेंशन की आवश्यकता होती है, तो हमेशा launch_persistent_context() के साथ शुरू करें। इसके अलावा, इसके द्वारा कुकीज और सत्र डेटा को संरक्षित किया जाता है, जो कैपचा आवृत्ति कम कर सकता है।
हेडलेस सर्वर पर Xvfb का उपयोग करें। क्रोम एक्सटेंशन के लिए एक डिस्प्ले संदर्भ की आवश्यकता होती है। अकेले डिस्प्ले वाले सर्वर परिदृश्यों में Xvfb की स्थापना करें।
अपने वातावरण के अनुरूप एकीकरण का उपयोग करें। जब आप सीधे क्रोमियम प्रक्रिया को नियंत्रित करते हैं और स्थायी संदर्भ लॉन्च करते हैं, तो एक्सटेंशन-आधारित दृष्टिकोण का उपयोग करें। जब आप नियंत्रित करने के लिए ब्राउजर लॉन्च करने के लिए नियंत्रित नहीं होते हैं - जैसे कि CDP के माध्यम से टिनीफिश ब्राउजर सत्र - तो कैपसॉल्वर SDK के साथ API-आधारित दृष्टिकोण का उपयोग करें।

निष्कर्ष

टिनीफिश एजेंटक्यूएल + कैपसॉल्वर एक अदृश्य कैपचा हल करने वाला एक ऐसा उपकरण है जो उपलब्ध अब तक के सबसे शक्तिशाली वेब ऑटोमेशन टूलकिट में आता है। कैपचा-हैंडलिंग कोड लिखने के बजाय, आप सिर्फ:

कैपसॉल्वर एक्सटेंशन डाउनलोड करें और अपने API कुंजी को कॉन्फिगर करें
एजेंटक्यूएल के प्लेयराइट ब्राउजर को एक्सटेंशन के साथ लॉन्च करें
अपने ऑटोमेशन स्क्रिप्ट आमतौर पर लिखें - फॉर्म भेजने से पहले एक वाइट समय जोड़ें

कैपसॉल्वर क्रोम एक्सटेंशन शेष काम करता है - कैपचा की पहचान, कैपसॉल्वर API के माध्यम से हल करना, और पृष्ठ में टोकन को एंग्रेट करना। आपके एजेंटक्यूएल स्क्रिप्ट को कैपचा के बारे में कभी भी ज्ञान नहीं होगा।

और जब आपका ऑटोमेशन एक रिमोट सत्र के बजाय एक रिमोट सत्र पर चलता है - जैसे कि टिनीफिश ब्राउजर - कैपसॉल्वर के API और SDK के माध्यम से आपको एक ही परिणाम प्राप्त करने के लिए कुछ अतिरिक्त कोड लाइनों की आवश्यकता होती है: सत्र के लिए अनुरोध करें, CDP के माध्यम से जुड़ें, हल करें, और एंग्रेट करें।

यह वह तरीका है जिस पर कैपचा हल करना दिखता है जब आप एआई-संचालित वेब ऑटोमेशन के साथ एआई-संचालित कैपचा हल करना जोड़ते हैं: अदृश्य, स्वचालित और कोड-मुक्त।

शुरू करने के लिए तैयार हैं? कैपसॉल्वर के लिए पंजीकरण करें और अपने पहले टॉप-अप में 6% अतिरिक्त प्राप्त करने के लिए बोनस कोड AGENTQL का उपयोग करें!

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

क्या मुझे अपने एजेंटक्यूएल स्क्रिप्ट में कैपचा-विशिष्ट कोड लिखना आवश्यक है?

नहीं। कैपसॉल्वर एक्सटेंशन प्लेयराइट ब्राउजर संदर्भ में पृष्ठभूमि में पूरी तरह से काम करता है। केवल फॉर्म भेजने से पहले time.sleep() या waitForTimeout() जोड़ें, और एक्सटेंशन डिटेक्शन, हल और टोकन इंजेक्शन स्वचालित रूप से हो जाता है।

मुझे क्यों एक स्थायी संदर्भ की आवश्यकता है?

प्लेयराइट केवल launch_persistent_context() के साथ क्रोम एक्सटेंशन समर्थित करता है। यह एक प्लेयराइट आर्किटेक्चर आवश्यकता है। सामान्य ब्राउजर संदर्भ जो browser.new_context() के माध्यम से बनाए गए हैं, एक्सटेंशन लोड नहीं कर सकते हैं।

क्या मैं हेडलेस मोड में चला सकता हूं?

नहीं। क्रोम एक्सटेंशन के लिए हेडेड ब्राउजर की आवश्यकता होती है। सर्वर परिदृश्यों में कोई भौतिक डिस्प्ले उपलब्ध न होने पर, Xvfb (X वर्चुअल फ्रेमबफर) का उपयोग करें।

क्या मैं अपने स्थानीय क्रोमियम के बजाय एक रिमोट टिनीफिश ब्राउजर सत्र का उपयोग कर रहा हूं?

चूंकि आप सीधे ब्राउजर लॉन्च को नियंत्रित नहीं करते हैं, आप टिनीफिश ब्राउजर सत्र में कैपसॉल्वर एक्सटेंशन लोड नहीं कर सकते हैं। बजाय इसके, कैपसॉल्वर SDK का उपयोग करके कैपचा हल करें और CDP के माध्यम से जुड़े हुए ब्राउजर पर page.evaluate() के माध्यम से परिणामी टोकन को एंग्रेट करें, जैसा कि ऊपर "कैपसॉल्वर का उपयोग टिनीफिश ब्राउजर के साथ" अनुभाग में दिखाया गया है।

कैपसॉल्वर कौन से कैपचा प्रकार समर्थित करता है?

कैपसॉल्वर reCAPTCHA v2 (चेकबॉक्स और अदृश्य), reCAPTCHA v3, Cloudflare Turnstile, AWS WAF CAPTCHA आदि के समर्थन करता है। एक्सटेंशन स्वचालित रूप से कैपचा प्रकार की पहचान करता है और इसे उसी अनुसार हल करता है।

कैपसॉल्वर की लागत क्या है?

कैपसॉल्वर विविधता और आवृत्ति के आधार पर प्रतिस्पर्धी दरों की पेशकश करता है। वर्तमान मूल्य देखने के लिए capsolver.com पर जाएं।

क्या टिनीफिश एजेंटक्यूएल मुक्त है?

एजेंटक्यूएल के मुक्त और भुगतान वाले टियर हैं। SDK और प्रश्न भाषा विकास और परीक्षण के लिए उपलब्ध है। tinyfish.ai पर मूल्य जांचें।

कैपचा हल होने में कितना समय लगता है?

अधिकांश कैपचा के लिए, 30-60 सेकंड पर्याप्त है। वास्तविक हल समय आमतौर पर 5-20 सेकंड होता है, लेकिन अतिरिक्त बफर विश्वसनीयता सुनिश्चित करता है। संदेह होने पर, 30 सेकंड का उपयोग करें।

और देखें

AIJul 31, 2026

ल्लामा इंडेक्स एजेंट्स में कैप्चा कैसे हल करें

LlamaIndex एजेंट्स में CAPTCHA हल करना एम्बेड करें FunctionTool और CapSolver का उपयोग करके वेब डेटा इनपुट पाइपलाइन के लिए।

Rajinder Singh

AIJul 31, 2026

CAPTCHA कैसे हल करें: CapSolver मॉडल संदर्भ प्रोटोकॉल सेवा

कैपसॉल्वर MCP सेवा को क्लॉड डेस्कटॉप, कर्सर और किसी भी MCP क्लाइंट में शून्य-कोड CAPTCHA हल करने के लिए सेट करें।