कैप्चा कैसे हल करें जब वेब स्क्रैपिंग करते हैं Scrapling और CapSolver के साथ

pip install scrapling

pip install "scrapling[fetchers]"
scrapling install

pip install "scrapling[all]"
scrapling install

from scrapling import Fetcher

# GET मांग
response = Fetcher.get("https://example.com")

# डेटा के साथ POST मांग
response = Fetcher.post("https://example.com/api", data={"key": "value"})

# प्रतिक्रिया के उपयोग
print(response.status)       # HTTP स्थिति कोड
print(response.body)         # कच्चे बाइट्स
print(response.body.decode()) # डिकोड किया गया पाठ

import requests
import time

CAPSOLVER_API_KEY = "आपकी आईपी ए कुंजी"

def solve_captcha(task_type, website_url, website_key, **kwargs):
    """
    कैपसॉल्वर एपीआई का उपयोग करके सामान्य कैपचा समाधानकर्ता।

    आर्ग्स:
        task_type: कैपचा के प्रकार (उदाहरण के लिए, "ReCaptchaV2TaskProxyLess")
        website_url: कैपचा के साथ पृष्ठ का URL
        website_key: कैपचा के लिए साइट कुंजी
        **kwargs: कैपचा प्रकार के लिए विशिष्ट अतिरिक्त पैरामीटर

    लौटाता है:
        dict: टोकन और अन्य डेटा के साथ समाधान का एक शब्दकोश
    """
    payload = {
        "clientKey": CAPSOLVER_API_KEY,
        "task": {
            "type": task_type,
            "websiteURL": website_url,
            "websiteKey": website_key,
            **kwargs
        }
    }

    # कार्य बनाएं
    response = requests.post(
        "https://api.capsolver.com/createTask",
        json=payload
    )
    result = response.json()

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

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

    # परिणाम प्राप्त करें
    max_attempts = 60  # अधिकतम 2 मिनट के लिए पॉलिंग
    for attempt in range(max_attempts):
        time.sleep(2)

        response = requests.post(
            "https://api.capsolver.com/getTaskResult",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "taskId": task_id
            }
        )
        result = response.json()

        if result.get("status") == "ready":
            print(f"कैपचा {((attempt + 1) * 2)} सेकंड में हल हो गया")
            return result.get("solution")

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

        print(f"इंतजार कर रहे हैं... (प्रयास {attempt + 1})")

    raise Exception("समय सीमा समाप्त: कैपचा हल करने में बहुत समय लग गया")

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

<script src="https://www.google.com/recaptcha/api.js?render=6LcxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxABCD"></script>

from scrapling import Fetcher

def scrape_with_recaptcha_v2(target_url, site_key, form_url=None):
    """
    ReCaptcha v2 से सुरक्षित पृष्ठ के स्क्रैप करें।

    आर्ग्स:
        target_url: कैपचा के साथ पृष्ठ का URL
        site_key: ReCaptcha साइट कुंजी
        form_url: फॉर्म जमा करने के लिए URL (डिफ़ॉल्ट लगभग target_url)

    लौटाता है:
        सुरक्षित पृष्ठ से प्रतिक्रिया
    """
    # CapSolver के साथ कैपचा हल करें
    print("ReCaptcha v2 हल कर रहे हैं...")
    solution = solve_captcha(
        task_type="ReCaptchaV2TaskProxyLess",
        website_url=target_url,
        website_key=site_key
    )

    captcha_token = solution["gRecaptchaResponse"]
    print(f"टोकन प्राप्त करें: {captcha_token[:50]}...")

    # कैपचा टोकन के साथ फॉर्म जमा करें उपयोग करके Scrapling
    # ध्यान दें: Fetcher.post() को क्लास विधि के रूप में उपयोग करें (इंस्टेंस विधि नहीं)
    submit_url = form_url or target_url
    response = Fetcher.post(
        submit_url,
        data={
            "g-recaptcha-response": captcha_token,
            # वेबसाइट द्वारा आवश्यक किसी अन्य फॉर्म फ़ील्ड को जोड़ें
        }
    )

    return response

# उदाहरण उपयोग
if __name__ == "__main__":
    url = "https://example.com/protected-page"
    site_key = "6LcxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxABCD"

    result = scrape_with_recaptcha_v2(url, site_key)
    print(f"स्थिति: {result.status}")
    print(f"सामग्री लंबाई: {len(result.body)}")  # .body का उपयोग कच्चे बाइट्स के लिए करें

solution = solve_captcha(
    task_type="ReCaptchaV2TaskProxyLess",
    website_url=target_url,
    website_key=site_key,
    isInvisible=True
)

solution = solve_captcha(
    task_type="ReCaptchaV2EnterpriseTaskProxyLess",
    website_url=target_url,
    website_key=site_key,
    enterprisePayload={
        "s": "आवश्यकता होने पर 'payload_s_value' मान"
    }
)

grecaptcha.execute('6LcxxxxxxxxxxxxxxxxABCD', {action: 'submit'})

from scrapling import Fetcher

def scrape_with_recaptcha_v3(target_url, site_key, page_action="submit", min_score=0.7):
    """
    ReCaptcha v3 से सुरक्षित पृष्ठ के स्क्रैप करें।

    आर्ग्स:
        target_url: कैपचा के साथ पृष्ठ का URL
        site_key: ReCaptcha साइट कुंजी
        page_action: कार्य पैरामीटर (grecaptcha.execute में पाए जाने वाले)
        min_score: अनुरोध करने के लिए न्यूनतम स्कोर (0.1-0.9)

    लौटाता है:
        सुरक्षित पृष्ठ से प्रतिक्रिया
    """
    print(f"ReCaptcha v3 (कार्य: {page_action}) हल कर रहे हैं...")

    solution = solve_captcha(
        task_type="ReCaptchaV3TaskProxyLess",
        website_url=target_url,
        website_key=site_key,
        pageAction=page_action
    )

    captcha_token = solution["gRecaptchaResponse"]
    print(f"स्कोर के साथ टोकन प्राप्त करें: {solution.get('score', 'एनए')}")

    # टोकन के साथ मांग जमा करें उपयोग करके Scrapling क्लास विधि
    response = Fetcher.post(
        target_url,
        data={
            "g-recaptcha-response": captcha_token,
        },
        headers={
            "User-Agent": solution.get("userAgent", "Mozilla/5.0")
        }
    )

    return response

# उदाहरण उपयोग
if __name__ == "__main__":
    url = "https://example.com/api/data"
    site_key = "6LcxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxABCD"

    result = scrape_with_recaptcha_v3(url, site_key, page_action="getData")
    print(f"प्रतिक्रिया: {result.body.decode()[:200]}")  # .body का उपयोग सामग्री के लिए करें

solution = solve_captcha(
    task_type="ReCaptchaV3EnterpriseTaskProxyLess",
    website_url=target_url,
    website_key=site_key,
    pageAction=page_action,
    enterprisePayload={
        "s": "वैकल्पिक s पैरामीटर"
    }
)

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

turnstile.render('#container', {
    sitekey: '0x4xxxxxxxxxxxxxxxxxxxxxxxxxx',
    callback: function(token) { ... }
});

from scrapling import Fetcher

def scrape_with_turnstile(target_url, site_key, action=None, cdata=None):
    """
    Cloudflare Turnstile से सुरक्षित पृष्ठ के स्क्रैप करें।

    आर्ग्स:
        target_url: कैपचा के साथ पृष्ठ का URL
        site_key: Turnstile साइट कुंजी (0x4... से शुरू होता है)
        action: वैकल्पिक कार्य पैरामीटर
        cdata: वैकल्पिक cdata पैरामीटर

    लौटाता है:
        सुरक्षित पृष्ठ से प्रतिक्रिया
    """
    print("Cloudflare Turnstile हल कर रहे हैं...")

    # आवश्यकता होने पर मेटाडेटा बनाएं
    metadata = {}
    if action:
        metadata["action"] = action
    if cdata:
        metadata["cdata"] = cdata

    task_params = {
        "task_type": "AntiTurnstileTaskProxyLess",
        "website_url": target_url,
        "website_key": site_key,
    }

    if metadata:
        task_params["metadata"] = metadata

    solution = solve_captcha(**task_params)

    turnstile_token = solution["token"]
    user_agent = solution.get("userAgent", "")

    print(f"Turnstile टोकन प्राप्त करें: {turnstile_token[:50]}...")

    # टोकन के साथ जमा करें उपयोग करके Scrapling क्लास विधि
    headers = {}
    if user_agent:
        headers["User-Agent"] = user_agent

    response = Fetcher.post(
        target_url,
        data={
            "cf-turnstile-response": turnstile_token,
        },
headers=headers
    )

    return response

# उदाहरण उपयोग
if __name__ == "__main__":
    url = "https://example.com/protected"
    site_key = "0x4AAAAAAAxxxxxxxxxxxxxx"

    result = scrape_with_turnstile(url, site_key)
    print(f"सफलता! {len(result.body)} बाइट्स प्राप्त किए गए")  # .body का उपयोग सामग्री के लिए करें

solution = solve_captcha(
    task_type="AntiTurnstileTaskProxyLess",
    website_url=target_url,
    website_key=site_key,
    metadata={
        "action": "लॉगिन",
        "cdata": "सेशन आईडी या कस्टम डेटा"
    }
)