pip install botasaurus

from botasaurus.browser import browser, Driver

@browser()
def scrape_page(driver: Driver, data):
    driver.get("https://example.com")
    title = driver.get_text("h1")
    return {"title": title}

# स्क्रैपर चलाएं
result = scrape_page()

pip install botasaurus capsolver requests python-dotenv

CAPSOLVER_API_KEY=CAP-अपना_API_KEY_यहां_रखें

# shared/config.py
import os
from pathlib import Path
from dotenv import load_dotenv

# परियोजना मूल से .env फ़ाइल लोड करें
ROOT_DIR = Path(__file__).parent.parent
load_dotenv(ROOT_DIR / ".env")

class Config:
    """कैपसॉल्वर एकीकरण के लिए व्यवस्था वर्ग।"""

    # कैपसॉल्वर API कुंजी
    CAPSOLVER_API_KEY: str = os.getenv("CAPSOLVER_API_KEY", "")

    # कैपसॉल्वर API एंडपॉइंट
    CAPSOLVER_API_URL = "https://api.capsolver.com"
    CREATE_TASK_ENDPOINT = f"{CAPSOLVER_API_URL}/createTask"
    GET_RESULT_ENDPOINT = f"{CAPSOLVER_API_URL}/getTaskResult"

    @classmethod
    def validate(cls) -> bool:
        """व्यवस्था वैधता की जांच करें।"""
        if not cls.CAPSOLVER_API_KEY:
            print("त्रुटि: CAPSOLVER_API_KEY सेट नहीं है!")
            return False
        return True

<div class="g-recaptcha" data-sitekey="6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"></div>

grecaptcha.render('container', {'sitekey': '6Le-xxxxx...'});

# utils/capsolver_helper.py
import time
import requests
from shared.config import Config

def solve_recaptcha_v2(
    website_url: str,
    website_key: str,
    is_invisible: bool = False,
    timeout: int = 120
) -> dict:
    """
    कैपसॉल्वर API के माध्यम से reCAPTCHA v2 हल करें।

    आर्ग्स:
        website_url: कैप्चा वाले पृष्ठ का URL
        website_key: reCAPTCHA साइट की
        is_invisible: क्या यह अदृश्य reCAPTCHA v2 है
        timeout: समाधान के लिए अधिकतम समय (सेकंड में)

    लौटाता है:
        'gRecaptchaResponse' टोकन के साथ डिक्ट
    """

    if not Config.validate():
        raise Exception("अमान्य व्यवस्था - अपना API कुंजी जांचें")

    # कार्य लोड बनाएं
    task = {
        "type": "ReCaptchaV2TaskProxyLess",
        "websiteURL": website_url,
        "websiteKey": website_key,
    }

    if is_invisible:
        task["isInvisible"] = True

    payload = {
        "clientKey": Config.CAPSOLVER_API_KEY,
        "task": task
    }

    # कार्य बनाएं
    response = requests.post(Config.CREATE_TASK_ENDPOINT, json=payload)
    result = response.json()

    if result.get("errorId") and result.get("errorId") != 0:
        raise Exception(f"कार्य बनाने में असफल: {result.get('errorDescription')}")

    task_id = result.get("taskId")

    # परिणाम के लिए पॉल
    start_time = time.time()
    while time.time() - start_time < timeout:
        time.sleep(2)

        result_payload = {
            "clientKey": Config.CAPSOLVER_API_KEY,
            "taskId": task_id
        }

        response = requests.post(Config.GET_RESULT_ENDPOINT, json=result_payload)
        result = response.json()

        if result.get("status") == "ready":
            return result.get("solution", {})

        elif result.get("status") == "failed":
            raise Exception(f"कार्य असफल: {result.get('errorDescription')}")

    raise Exception(f"{timeout} सेकंड के बाद समय सीमा समाप्त हो गई")

from botasaurus.browser import browser, Driver
from shared.config import Config
from utils.capsolver_helper import solve_recaptcha_v2

DEMO_URL = "https://www.google.com/recaptcha/api2/demo"
DEMO_SITEKEY = "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"

@browser(headless=False)
def solve_recaptcha_v2_with_api(driver: Driver, data: dict):
    """कैपसॉल्वर API के माध्यम से reCAPTCHA v2 हल करें और टोकन निवेश करें।"""

    url = data.get("url", DEMO_URL)
    site_key = data.get("site_key", DEMO_SITEKEY)

    # चरण 1: पृष्ठ लोड करें
    driver.get(url)
    driver.sleep(2)

    # चरण 2: पृष्ठ से साइट की निकालें (वैकल्पिक)
    extracted_key = driver.run_js("""
        const recaptchaDiv = document.querySelector('.g-recaptcha');
        return recaptchaDiv ? recaptchaDiv.getAttribute('data-sitekey') : null;
    """)

    if extracted_key:
        site_key = extracted_key

    # चरण 3: कैपसॉल्वर API के माध्यम से कैप्चा हल करें
    solution = solve_recaptcha_v2(
        website_url=url,
        website_key=site_key
    )

    token = solution.get("gRecaptchaResponse")

    # चरण 4: टोकन को पृष्ठ में निवेश करें
    driver.run_js(f"""
        // छिपे हुए टेक्स्ट क्षेत्र के मान को सेट करें
        const responseField = document.querySelector('[name="g-recaptcha-response"]');
        if (responseField) {{
            responseField.value = "{token}";
        }}

        // यदि उपलब्ध हो तो कॉलबैक ट्रिगर करें
        if (typeof ___grecaptcha_cfg !== 'undefined') {{
            try {{
                const clients = ___grecaptcha_cfg.clients;
                for (const key in clients) {{
                    const client = clients[key];
                    if (client && client.callback) {{
                        client.callback("{token}");
                    }}
                }}
            }} catch (e) {{}}
        }}
    """)

    # चरण 5: फॉर्म जमा करें
    submit_button = driver.select('input[type="submit"]')
    if submit_button:
        submit_button.click()
        driver.sleep(2)

    return {"success": True, "token_length": len(token)}

# डेमो चलाएं
result = solve_recaptcha_v2_with_api(data={"url": DEMO_URL, "site_key": DEMO_SITEKEY})

grecaptcha.execute('siteKey', {action: 'login'})
// 'login' आपका pageAction है

def solve_recaptcha_v3(
    website_url: str,
    website_key: str,
    page_action: str,
    timeout: int = 120
) -> dict:
    """
    कैपसॉल्वर API के माध्यम से reCAPTCHA v3 हल करें।

    आर्ग्स:
        website_url: कैप्चा वाले पृष्ठ का URL
        website_key: reCAPTCHA साइट की
        page_action: कैप्चा एक्शन पैरामीटर (v3 के लिए आवश्यक है)
        timeout: समाधान के लिए अधिकतम समय (सेकंड में)

    लौटाता है:
        'gRecaptchaResponse' टोकन के साथ डिक्ट
    """

    if not Config.validate():
        raise Exception("अमान्य व्यवस्था - अपना API कुंजी जांचें")

    if not page_action:
        raise Exception("reCAPTCHA v3 के लिए pageAction आवश्यक है")

    # कार्य लोड बनाएं
    task = {
        "type": "ReCaptchaV3TaskProxyLess",
        "websiteURL": website_url,
        "websiteKey": website_key,
        "pageAction": page_action,  # v3 के लिए आवश्यक है
    }

    payload = {
        "clientKey": Config.CAPSOLVER_API_KEY,
        "task": task
    }

    # कार्य बनाएं
    response = requests.post(Config.CREATE_TASK_ENDPOINT, json=payload)
    result = response.json()

    if result.get("errorId") and result.get("errorId") != 0:
        raise Exception(f"कार्य बनाने में असफल: {result.get('errorDescription')}")

    task_id = result.get("taskId")

    # परिणाम के लिए पॉल
    start_time = time.time()
    while time.time() - start_time < timeout:
        time.sleep(2)

        result_payload = {
            "clientKey": Config.CAPSOLVER_API_KEY,
            "taskId": task_id
        }

        response = requests.post(Config.GET_RESULT_ENDPOINT, json=result_payload)
        result = response.json()

        if result.get("status") == "ready":
            return result.get("solution", {})

        elif result.get("status") == "failed":
            raise Exception(f"कार्य असफल: {result.get('errorDescription')}")

    raise Exception(f"{timeout} सेकंड के बाद समय सीमा समाप्त हो गई")

from botasaurus.browser import browser, Driver
from shared.config import Config
from utils.capsolver_helper import solve_recaptcha_v3

DEMO_URL = "https://recaptcha-demo.appspot.com/recaptcha-v3-request-scores.php"
DEMO_SITEKEY = "6LdyC2cUAAAAACGuDKpXeDorzUDWXmdqeg-xy696"
PAGE_ACTION = "examples/v3scores"

@browser(headless=False)
def solve_recaptcha_v3_with_api(driver: Driver, data: dict):
    """कैपसॉल्वर API के माध्यम से reCAPTCHA v3 हल करें और टोकन निवेश करें।"""

    url = data.get("url", DEMO_URL)
    site_key = data.get("site_key", DEMO_SITEKEY)
    page_action = data.get("page_action", PAGE_ACTION)

    # चरण 1: पृष्ठ लोड करें
    driver.get(url)
    driver.sleep(2)

    # चरण 2: कैप्चा को कैपसॉल्वर API के माध्यम से हल करें
    solution = solve_recaptcha_v3(
        website_url=url,
        website_key=site_key,
        page_action=page_action
    )

    token = solution.get("gRecaptchaResponse")

    # चरण 3: टोकन को पृष्ठ में निवेश करें
    driver.run_js(f"""
        const token = "{token}";

        // छिपे हुए क्षेत्र को सेट करें यदि उपलब्ध है
        const responseField = document.querySelector('[name="g-recaptcha-response"]');
        if (responseField) {{
            responseField.value = token;
        }}

        // यदि फॉर्म मौजूद है लेकिन क्षेत्र नहीं है, छिपे हुए क्षेत्र बनाएं
        const forms = document.querySelectorAll('form');
        forms.forEach(form => {{
            let field = form.querySelector('[name="g-recaptcha-response"]');
            if (!field) {{
                field = document.createElement('input');
                field.type = 'hidden';
                field.name = 'g-recaptcha-response';
                form.appendChild(field);
            }}
            field.value = token;
        }});
    """)

    # चरण 4: सत्यापित करें या फॉर्म जमा करें
    buttons = driver.select_all("button")
    for button in buttons:
        if "सत्यापित" या "जमा" पर बटन के लिए बनाएं:
            button.click()
            driver.sleep(2)
            break

    return {"success": True, "token_length": len(token)}

# डेमो चलाएं
result = solve_recaptcha_v3_with_api(data={
    "url": DEMO_URL,
    "site_key": DEMO_SITEKEY,
    "page_action": PAGE_ACTION
})

<div class="cf-turnstile" data-sitekey="0x4AAAAAAABS7vwvV6VFfMcD"></div>

def solve_turnstile(
    website_url: str,
    website_key: str,
    action: str = None,
    cdata: str = None,
    timeout: int = 120
) -> dict:
    """
समाधान क्लाउडफ़्लेर टर्नस्टाइल कैपसॉल्वर API के साथ।

    आर्ग्स:
        website_url: टर्नस्टाइल वाले पृष्ठ का URL
        website_key: टर्नस्टाइल साइट कुंजी (0x4 से शुरू होती है)
        action: डेटा-एक्शन एट्रिब्यूट से वैकल्पिक कार्य
        cdata: डेटा-सीडेटा एट्रिब्यूट से वैकल्पिक सीडेटा
        timeout: समाधान के लिए प्रतीक्षा करने का अधिकतम समय (सेकंड में)

    वापसी:
        'टोकन' क्षेत्र वाला डिक्शनरी
    """

    if not Config.validate():
        raise Exception("अमान्य कॉन्फ़िगरेशन - अपने API कुंजी की जांच करें")

    # कार्य भार बनाएं
    task = {
        "type": "AntiTurnstileTaskProxyLess",
        "websiteURL": website_url,
        "websiteKey": website_key,
    }

    # वैकल्पिक मेटाडेटा जोड़ें
    metadata = {}
    if action:
        metadata["action"] = action
    if cdata:
        metadata["cdata"] = cdata

    if metadata:
        task["metadata"] = metadata

    payload = {
        "clientKey": Config.CAPSOLVER_API_KEY,
        "task": task
    }

    # कार्य बनाएं
    response = requests.post(Config.CREATE_TASK_ENDPOINT, json=payload)
    result = response.json()

    if result.get("errorId") and result.get("errorId") != 0:
        raise Exception(f"कार्य बनाने में विफल: {result.get('errorDescription')}")

    task_id = result.get("taskId")

    # परिणाम के लिए पॉल
    start_time = time.time()
    while time.time() - start_time < timeout:
        time.sleep(2)

        result_payload = {
            "clientKey": Config.CAPSOLVER_API_KEY,
            "taskId": task_id
        }

        response = requests.post(Config.GET_RESULT_ENDPOINT, json=result_payload)
        result = response.json()

        if result.get("status") == "ready":
            return result.get("solution", {})

        elif result.get("status") == "failed":
            raise Exception(f"कार्य विफल: {result.get('errorDescription')}")

    raise Exception(f"{timeout} सेकंड के बाद समय सीमा समाप्त")

from botasaurus.browser import browser, Driver
from shared.config import Config
from utils.capsolver_helper import solve_turnstile

DEMO_URL = "https://peet.ws/turnstile-test/non-interactive.html"
DEMO_SITEKEY = "0x4AAAAAAABS7vwvV6VFfMcD"

@browser(headless=False)
def solve_turnstile_with_api(driver: Driver, data: dict):
    """कैपसॉल्वर API के साथ क्लाउडफ़्लेर टर्नस्टाइल हल करें और टोकन इंजेक्ट करें।"""

    url = data.get("url", DEMO_URL)
    site_key = data.get("site_key", DEMO_SITEKEY)

    # चरण 1: पृष्ठ लोड करें
    driver.get(url)
    driver.sleep(3)

    # चरण 2: पृष्ठ से साइट कुंजी निकालें (वैकल्पिक)
    extracted_params = driver.run_js("""
        const turnstileDiv = document.querySelector('.cf-turnstile, [data-sitekey]');
        if (turnstileDiv) {
            const key = turnstileDiv.getAttribute('data-sitekey');
            if (key && key.startsWith('0x')) {
                return {
                    sitekey: key,
                    action: turnstileDiv.getAttribute('data-action')
                };
            }
        }
        return null;
    """)

    if extracted_params and extracted_params.get("sitekey"):
        site_key = extracted_params["sitekey"]

    # चरण 3: कैपसॉल्वर API के माध्यम से टर्नस्टाइल हल करें
    solution = solve_turnstile(
        website_url=url,
        website_key=site_key,
        action=extracted_params.get("action") if extracted_params else None
    )

    token = solution.get("token")

    # चरण 4: टोकन को पृष्ठ में इंजेक्ट करें
    driver.run_js(f"""
        const token = "{token}";

        // cf-turnstile-response फ़ील्ड खोजें और भरें
        const responseFields = [
            document.querySelector('[name="cf-turnstile-response"]'),
            document.querySelector('[name="cf_turnstile_response"]'),
            document.querySelector('input[name*="turnstile"]')
        ];

        for (const field of responseFields) {{
            if (field) {{
                field.value = token;
                break;
            }}
        }}

        // यदि फॉर्म मौजूद है लेकिन फ़ील्ड नहीं है, तो छिपा फ़ील्ड बनाएं
        const forms = document.querySelectorAll('form');
        forms.forEach(form => {{
            let field = form.querySelector('[name="cf-turnstile-response"]');
            if (!field) {{
                field = document.createElement('input');
                field.type = 'hidden';
                field.name = 'cf-turnstile-response';
                form.appendChild(field);
            }}
            field.value = token;
        }});
    """)

    # चरण 5: फॉर्म जमा करें
    submit_btn = driver.select('button[type="submit"], input[type="submit"]')
    if submit_btn:
        submit_btn.click()
        driver.sleep(2)

    return {"success": True, "token_length": len(token)}

# डेमो चलाएं
result = solve_turnstile_with_api(data={"url": DEMO_URL, "site_key": DEMO_SITEKEY})

# टोकन प्राप्त करें
solution = solve_recaptcha_v2(url, site_key)
token = solution.get("gRecaptchaResponse")

# तुरंत उपयोग करें - बाद में भंडारण न करें
driver.run_js(f'document.querySelector("[name=g-recaptcha-response]").value = "{token}"')
driver.select('button[type="submit"]').click()

try:
    solution = solve_recaptcha_v2(url, site_key)
except Exception as e:
    print(f"कैपचा समाधान विफल: {e}")
    # पुन: प्रयास लॉजिक या फॉलबैक लागू करें

driver.sleep(2)  # पृष्ठ लोड के बाद प्रतीक्षा करें
# ... कैपचा हल करें ...
driver.sleep(1)  # फॉर्म जमा करने से पहले प्रतीक्षा करें

if not Config.validate():
    raise Exception("कृपया .env फ़ाइल में अपने API कुंजी की कॉन्फ़िगरेशन करें")