हेलियम के साथ कैपसॉल्वर को एकीकृत कैसे करें सुचारू CAPTCHA हल करने के लिए

# हेलियम स्थापित करें
pip install helium

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

from helium import *

# ब्राउजर शुरू करें और नेविगेट करें
start_chrome("https://wikipedia.org")

# खोज बॉक्स में टाइप करें
write("Python programming", into=S("input[name='search']"))

# खोज बटन पर क्लिक करें
click(Button("Search"))

# यदि पाठ मौजूद है तो जांचें
if Text("Python").exists():
    print("Python लेख पाया गया!")

# ब्राउजर बंद करें
kill_browser()

pip install helium requests

import time
import requests
from helium import *

CAPSOLVER_API_KEY = "आपका एपीआई कुंजी"
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:
    """कार्य परिणाम के

![हेलियम के साथ कैपसॉल्वर के एकीकरण के साथ](https://assets.capsolver.com/prod/posts/helium-capsolver/JisQhgZpPFfU-78e1506be0b22398b8f14cf95333404c.png)


## 1. परिचय

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

**हेलियम** और **कैपसॉल्वर** के संयोजन एक शीर्ष उत्तर प्रदान करते हैं:

- **हेलियम**: सेलेनियम के साथ आसान उपयोग के लिए एक हल्का पायथन पुस्तकालय जो एक सरल, मानव-पठनीय API प्रदान करता है
- **कैपसॉल्वर**: क्लाउडफ़ेयर टर्नस्टाइल, रीकैप्चा आदि जैसे अधिक कैप्चा के समाधान के लिए एआई-आधारित कैप्चा हल करने वाली सेवा

इन उपकरणों के साथ, आसान वेब ऑटोमेशन संभव होता है जो कैप्चा चुनौतियों को स्वचालित रूप से हल करता है।

### 1.1. एकीकरण लक्ष्य

इस गाइड आपको तीन मुख्य लक्ष्य प्राप्त करने में मदद करेगा:

1. **ब्राउजर ऑटोमेशन सरल करें** - स्पष्ट, पठनीय कोड के लिए हेलियम के संगत API का उपयोग करें
2. **कैप्चा स्वचालित रूप से हल करें** - कैपसॉल्वर के API के साथ एकीकृत करें ताकि कैप्चा चुनौतियों को हस्तचालित बिना हल किया जा सके
3. **लचीलापन बनाए रखें** - आवश्यकता पड़ने पर सेलेनियम की पूरी शक्ति के लिए पहुंच प्राप्त करें जबकि कोड सरल रहता है

## 2. हेलियम क्या है?

[हेलियम](https://github.com/mherrmann/helium) एक पायथन पुस्तकालय है जो सेलेनियम के उपयोग को आसान बनाता है। यह एक उच्च स्तर के API प्रदान करता है जो आम भाषा में ब्राउजर ऑटोमेशन लिखने की अनुमति देता है।

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

- **सरल सिंटैक्स** - जटिल XPath चयनकर्ता के बजाय `click("Submit")` लिखें
- **ऑटो-वाइटिंग** - तत्व उपलब्ध होने तक स्वतः प्रतीक्षा करें
- **मानव-पठनीय** - कोड निर्देशों के तरह पढ़ें: `write("Hello", into="Search")`
- **सेलेनियम संगत** - आवश्यकता पड़ने पर बेसिक सेलेनियम ड्राइवर तक पहुंच प्राप्त करें
- **हल्का** - सेलेनियम पर न्यूनतम ओवरहेड

### 2.2. स्थापना

```bash
# हेलियम स्थापित करें
pip install helium

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

from helium import *

# ब्राउजर शुरू करें और नेविगेट करें
start_chrome("https://wikipedia.org")

# खोज बॉक्स में टाइप करें
write("Python programming", into=S("input[name='search']"))

# खोज बटन पर क्लिक करें
click(Button("Search"))

# यदि पाठ मौजूद है तो जांचें
if Text("Python").exists():
    print("Python लेख पाया गया!")

# ब्राउजर बंद करें
kill_browser()

pip install helium requests

import time
import requests
from helium import *

CAPSOLVER_API_KEY = "आपका एपीआई कुंजी"
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)

    print("reCAPTCHA v3 bypassed!")

finally:
    kill_browser()

## 7. शीर्ष व्यवहार

### 7.1. ब्राउजर की समायोजन

सामान्य ब्राउजर के रूप में च्रोम को कॉन्फ़िगर करें:

```python
from helium import *
from selenium.webdriver import ChromeOptions

options = ChromeOptions()
options.add_experimental_option('excludeSwitches', ['enable-automation'])
options.add_experimental_option('useAutomationExtension', False)
options.add_argument('--disable-blink-features=AutomationControlled')
options.add_argument('--window-size=1920,1080')

start_chrome(options=options)

from helium import *

start_chrome("https://target-site.com")

# हेलियम के साथ सरल अंतःक्रियाएं करें
write("username", into="Email")
write("password", into="Password")

# जटिल ऑपरेशन के लिए सेलेनियम ड्राइवर का उपयोग करें
driver = get_driver()
driver.execute_script("window.scrollTo(0, document.body.scrollHeight)")

# हेलियम पर वापस आएं
click("Login")

import random
import time

def human_delay(min_sec=1.0, max_sec=3.0):
    """मानव व्यवहार के अनुकरण के लिए यादृच्छिक देरी।"""
    time.sleep(random.uniform(min_sec, max_sec))

# कार्यों के बीच उपयोग करें
click("Next")
human_delay()
write("data", into="Input")

def solve_with_retry(task_payload: dict, max_retries: int = 3) -> dict:
    """पुन: प्रयास ताकत के साथ CAPTCHA हल करें।"""
    for attempt in range(max_retries):
        try:
            return solve_captcha(task_payload)
        except TimeoutError:
            if attempt < max_retries - 1:
                print(f"समय सीमा पार हो गई, पुन: प्रयास कर रहे हैं... ({attempt + 1}/{max_retries})")
                time.sleep(5)
            else:
                raise
        except Exception as e:
            if "balance" in str(e).lower():
                raise  # बैलेंस त्रुटि के लिए पुन: प्रयास न करें
            if attempt < max_retries - 1:
                time.sleep(2)
            else:
                raise

from helium import *
from selenium.webdriver import ChromeOptions

options = ChromeOptions()
options.add_argument('--headless')
options.add_argument('--disable-gpu')

start_chrome("https://target-site.com", options=options)