ड्रिसियनपेज के साथ कैपसॉल्वर कैसे एकीकृत करें: सीमलेस CAPTCHA हल करें

# DrissionPage स्थापित करें
pip install DrissionPage

# कैपसॉल्वर API के लिए requests लाइब्रेरी स्थापित करें
pip install requests

from DrissionPage import ChromiumPage

# ब्राउज़र अनुभव बनाएं
page = ChromiumPage()

# URL पर जाएं
page.get('https://wikipedia.org')

# तत्वों को खोजें और बातचीत करें
page('#search-input').input('हैलो वर्ल्ड')
page('#submit-btn').click()

pip install DrissionPage requests

import time
import requests
from DrissionPage import ChromiumPage

CAPSOLVER_API_KEY = "आपका API की"
CAPSOLVER_API = "https://api.capsolver.com"


def create_task(task_payload: dict) -> str:
    """कैपचा हल करने के कार्य को बनाएं और कार्य पहचानकर्ता लौटाएं।"""
    response = requests.post(
        f"{CAPSOLVER_API}/createTask",
        json={
            "clientKey": CAPSOLVER_API_KEY,
            "task": task_payload
        }
    )
    result = response.json()
    if result.get("errorId") != 0:
        raise Exception(f"कैपसॉल्वर त्रुटि: {result.get('errorDescription')}")
    return result["taskId"]


def get_task_result(task_id: str, max_attempts: int = 120) -> dict:
    """समाधान या समय सीमा समाप्त होने तक कार्य परिणाम के लिए पॉल करें।"""
    for _ in range(max_attempts):
        response = requests.post(
            f"{CAPSOLVER_API}/getTaskResult",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "taskId": task_id
            }
        )
        result = response.json()

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

        time.sleep(1)

    raise TimeoutError("कैपचा हल करने में समय सीमा समाप्त हो गई")


def solve_captcha(task_payload: dict) -> dict:
    """कैपचा हल करने की पूर्ण प्रक्रिया पूरी करें।"""
    task_id = create_task(task_payload)
    return get_task_result(task_id)

// एक्सटेंशन फ़ोल्डर में, संपादित करें: assets/config.js
var defined = {
    apiKey: "आपका कैपसॉल्वर API की",  // अपने वास्तविक API की बदलें
    enabledForBlacklistControl: false,
    blackUrlList: [],
    enabledForRecaptcha: true,
    enabledForRecaptchaV3: true,
    enabledForTurnstile: true,
    // ... अन्य सेटिंग्स
}

from DrissionPage import ChromiumPage, ChromiumOptions

co = ChromiumOptions()
co.add_extension('/path/to/capsolver-extension')

page = ChromiumPage(co)
# एक्सटेंशन कैपचा को स्वचालित रूप से पहचानेगा और हल करेगा

import time
import requests
from DrissionPage import ChromiumPage

CAPSOLVER_API_KEY = "आपका API की"
CAPSOLVER_API = "https://api.capsolver.com"


def solve_turnstile(site_key: str, page_url: str) -> str:
    """क्लाउडफ़्लेर टर्नस्टाइल को हल करें और टोकन लौटाएं।"""
    # कार्य बनाएं
    response = requests.post(
        f"{CAPSOLVER_API}/createTask",
        json={
            "clientKey": CAPSOLVER_API_KEY,
            "task": {
                "type": "AntiTurnstileTaskProxyLess",
                "websiteURL": page_url,
                "websiteKey": site_key,
            }
        }
    )
    result = response.json()

    if result.get("errorId") != 0:
        raise Exception(f"त्रुटि: {result.get('errorDescription')}")

    task_id = result["taskId"]

    # परिणाम के लिए पॉल करें
    while True:
        result = requests.post(
            f"{CAPSOLVER_API}/getTaskResult",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "taskId": task_id
            }
        ).json()

        if result.get("status") == "ready":
            return result["solution"]["token"]
        elif result.get("status") == "failed":
            raise Exception(f"विफल: {result.get('errorDescription')}")

        time.sleep(1)


def main():
    लक्ष्य_पृष्ठ = "https://आपका-लक्ष्य-साइट.com"
    टर्नस्टाइल_साइट_की = "0x4XXXXXXXXXXXXXXXXX"  # पृष्ठ के स्रोत में ढूंढें

    # ब्राउज़र अनुभव बनाएं
    page = ChromiumPage()
    page.get(लक्ष्य_पृष्ठ)

    # टर्नस्टाइल लोड होने के लिए प्रतीक्षा करें
    page.wait.ele_displayed('input[name="cf-turnstile-response"]', timeout=10)

    # कैपचा हल करें
    टोकन = solve_turnstile(टर्नस्टाइल_साइट_की, लक्ष्य_पृष्ठ)
    print(f"टर्नस्टाइल टोकन प्राप्त किया: {टोकन[:50]}...")

    # टोकन को जावास्क्रिप्ट के माध्यम से निवेश करें
    page.run_js(f'''
        document.querySelector('input[name="cf-turnstile-response"]').value = "{टोकन}";

        // यदि उपलब्ध हो तो कॉलबैक ट्रिगर करें
        const callback = document.querySelector('[data-callback]');
        if (callback) {{
            const callbackName = callback.getAttribute('data-callback');
            if (window[callbackName]) {{
                window[callbackName]('{टोकन}');
            }}
        }}
    ''')

    # फॉर्म जमा करें
    page('button[type="submit"]').click()
    page.wait.load_start()

    print("टर्नस्टाइल को सफलतापूर्वक पार कर गए!")


if __name__ == "__main__":
    main()

import time
import requests
from DrissionPage import ChromiumPage, ChromiumOptions

CAPSOLVER_API_KEY = "आपका API की"
CAPSOLVER_API = "https://api.capsolver.com"


def solve_recaptcha_v2(site_key: str, page_url: str) -> str:
    """reCAPTCHA v2 को हल करें और टोकन लौटाएं।"""
    # कार्य बनाएं
    response = requests.post(
        f"{CAPSOLVER_API}/createTask",
        json={
            "clientKey": CAPSOLVER_API_KEY,
            "task": {
                "type": "ReCaptchaV2TaskProxyLess",
                "websiteURL": page_url,
                "websiteKey": site_key,
            }
        }
    )
    result = response.json()

    if result.get("errorId") != 0:
        raise Exception(f"त्रुटि: {result.get('errorDescription')}")

    task_id = result["taskId"]
    print(f"कार्य बनाया गया: {task_id}")

    # परिणाम के लिए पॉल करें
    while True:
        result = requests.post(
            f"{CAPSOLVER_API}/getTaskResult",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "taskId": task_id
            }
        ).json()

        if result.get("status") == "ready":
            return result["solution"]["gRecaptchaResponse"]
        elif result.get("status") == "failed":
            raise Exception(f"विफल: {result.get('errorDescription')}")

        time.sleep(1)


def main():
    # केवल URL प्रदान करें - साइट की स्वचालित रूप से पहचानी जाएगी
    लक्ष्य_पृष्ठ = "https://www.google.com/recaptcha/api2/demo"

    # ब्राउज़र कॉन्फ़िगर करें
    co = ChromiumOptions()
    co.set_argument('--disable-blink-features=AutomationControlled')

    print("ब्राउज़र शुरू कर रहा है...")
    page = ChromiumPage(co)

    try:
        page.get(लक्ष्य_पृष्ठ)
        time.sleep(2)

        # पृष्ठ से साइट की स्वचालित रूप से पहचानें
        recaptcha_div = page('.g-recaptcha')
        if not recaptcha_div:
            print("पृष्ठ पर कोई reCAPTCHA नहीं मिला!")
            return

        site_key = recaptcha_div.attr('data-sitekey')
        print(f"स्वचालित रूप से पहचानी गई साइट की: {site_key}")

        # कैपचा हल करें
        print("reCAPTCHA v2 हल कर रहा है...")
        token = solve_recaptcha_v2(site_key, लक्ष्य_पृष्ठ)
        print(f"टोकन प्राप्त किया: {token[:50]}...")

        # टोकन निवेश करें
        page.run_js(f'''
            var responseField = document.getElementById('g-recaptcha-response');
            responseField.style.display = 'block';
            responseField.value = '{token}';
        ''')
        print("टोकन निवेश किया गया!")

        # फॉर्म जमा करें
        submit_btn = page('#recaptcha-demo-submit') or page('input[type="submit"]') or page('button[type="submit"]')
        if submit_btn:
            submit_btn.click()
            time.sleep(3)
            print("फॉर्म जमा कर दिया!")

        print(f"वर्तमान URL: {page.url}")
        print("सफलता!")

    finally:
        page.quit()


if __name__ == "__main__":
    main()

python recaptcha_demo.py

import time
import requests
from DrissionPage import ChromiumPage, ChromiumOptions

CAPSOLVER_API_KEY = "आपका API की"
CAPSOLVER_API = "https://api.capsolver.com"


def solve_recaptcha_v3(
    site_key: str,
    page_url: str,
    action: str = "verify",
    min_score: float = 0.7
) -> str:
    """निर्दिष्ट कार्य और न्यूनतम स्कोर के साथ reCAPTCHA v3 हल करें।"""
    response = requests.post(
        f"{CAPSOLVER_API}/createTask",
        json={
            "clientKey": CAPSOLVER_API_KEY,
            "task": {
                "type": "ReCaptchaV3TaskProxyLess",
                "websiteURL": page_url,
                "websiteKey": site_key,
                "pageAction": action,
                "minScore": min_score
            }
        }
    )
    result = response.json()

    if result.get("errorId") != 0:
        raise Exception(f"त्रुटि: {result.get('errorDescription')}")

    task_id = result["taskId"]

    while True:
        result = requests.post(
            f"{CAPSOLVER_API}/getTaskResult",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "taskId": task_id
            }
        ).json()

        if result.get("status") == "ready":
            return result["solution"]["gRecaptchaResponse"]
        elif result.get("status") == "failed":
            raise Exception(f"विफल: {result.get('errorDescription')}")

        time.sleep(1)


def main():
    लक्ष्य_पृष्ठ = "https://आपका-लक्ष्य-साइट.com"
    recaptcha_v3_key = "6LcXXXXXXXXXXXXXXXXXXXXXXXXX"

    # v3 के लिए हेडलेस ब्राउज़र सेट करें
    co = ChromiumOptions()
    co.headless()

    page = ChromiumPage(co)
    page.get(लक्ष्य_पृष्ठ)

    # "खोज" कार्य के साथ reCAPTCHA v3 हल करें
    print("reCAPTCHA v3 हल कर रहा है...")
    token = solve_recaptcha_v3(
        recaptcha_v3_key,
        लक्ष्य_पृष्ठ,
        action="खोज",
        min_score=0.9  # उच्च स्कोर के लिए अनुरोध करें
    )

    # टोकन के साथ कॉलबैक चलाएं
    page.run_js(f'''
        // यदि कॉलबैक फ़ंक्शन उपलब्ध है, तो इसे टोकन के साथ कॉल करें
        if (typeof onRecaptchaSuccess === 'function') {{
            onRecaptchaSuccess('{token}');
        }}
    ''')
    print("टंत्र चलाया गया!")

    print(f"वर्तमान URL: {page.url}")
    print("सफलता!")

if __name__ == "__main__":
    main()