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

# पायथन पैकेज स्थापित करें
pip install -U camoufox[geoip]

# कैमूफॉक्स ब्राउज़र डाउनलोड करें
camoufox fetch

from camoufox.sync_api import Camoufox

with Camoufox(humanize=True) as browser:
    page = browser.new_page()
    page.goto("https://example.com")

pip install camoufox[geoip] httpx

import asyncio
import httpx
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "आपका_एपी_कुंजी"
CAPSOLVER_API = "https://api.capsolver.com"


async def create_task(task_payload: dict) -> str:
    """कैप्चा हल करने के कार्य को बनाएं और कार्य पहचान लें।"""
    async with httpx.AsyncClient() as client:
        response = await client.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"]


async def get_task_result(task_id: str, max_attempts: int = 120) -> dict:
    """समाधान या समय सीमा समाप्त होने तक कार्य परिणाम के लिए पॉल करें।"""
    async with httpx.AsyncClient() as client:
        for _ in range(max_attempts):
            response = await client.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')}")

            await asyncio.sleep(1)

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

from camoufox.sync_api import Camoufox

with Camoufox(
    addons=["/path/to/capsolver-extension"],
    headless=False  # एक्सटेंशन के लिए हेडलेस मोड काम नहीं करता
) as browser:
    page = browser.new_page()
    # एक्सटेंशन स्वचालित रूप से कैप्चा को हल करेगा

import asyncio
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "आपका_एपी_कुंजी"
CAPSOLVER_API = "https://api.capsolver.com"


async def solve_turnstile(site_key: str, page_url: str) -> str:
    """क्लाउडफ़्लेर टर्नस्टाइल हल करें और टोकन लौटाएं।"""
    import httpx

    async with httpx.AsyncClient() as client:
        # कार्य बनाएं
        response = await client.post(
            f"{CAPSOLVER_API}/createTask",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "task": {
                    "type": "AntiTurnstileTaskProxyLess",
                    "websiteURL": page_url,
                    "websiteKey": site_key,
                }
            }
        )
        task_id = response.json()["taskId"]

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

            if data.get("status") == "ready":
                return data["solution"]["token"]

            await asyncio.sleep(1)


async def main():
    target_url = "https://example.com/protected-page"
    turnstile_site_key = "0x4XXXXXXXXXXXXXXXXX"  # पेज स्रोत में ढूंढें

    async with AsyncCamoufox(
        humanize=True,
        headless=False,
        os="windows"
    ) as browser:
        page = await browser.new_page()
        await page.goto(target_url)

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

        # कैप्चा हल करें
        token = await solve_turnstile(turnstile_site_key, target_url)
        print(f"टर्नस्टाइल टोकन प्राप्त करें: {token[:50]}...")

        # टोकन इंजेक्ट करें
        await page.evaluate(f'''
            document.querySelector('input[name="cf-turnstile-response"]').value = "{token}";

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

        # फॉर्म भेजें
        await page.click('button[type="submit"]')
        await page.wait_for_load_state("networkidle")

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


if __name__ == "__main__":
    asyncio.run(main())

import asyncio
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "आपका_एपी_कुंजी"
CAPSOLVER_API = "https://api.capsolver.com"


async def solve_recaptcha_v2(site_key: str, page_url: str) -> str:
    """reCAPTCHA v2 हल करें और टोकन लौटाएं।"""
    import httpx

    async with httpx.AsyncClient() as client:
        # कार्य बनाएं
        response = await client.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"]

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

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

            await asyncio.sleep(2)


async def main():
    target_url = "https://example.com/login"
    recaptcha_site_key = "6LcXXXXXXXXXXXXXXXXXXXXXXXXX"  # पेज स्रोत में ढूंढें

    async with AsyncCamoufox(
        humanize=True,
        headless=False,
        os=["windows", "macos"]  # यादृच्छिक ओएस चयन
    ) as browser:
        page = await browser.new_page()
        await page.goto(target_url)

        # मानव-जैसी देरी के साथ फॉर्म फ़ील्ड भरें
        await page.fill('input[name="username"]', "[email protected]")
        await asyncio.sleep(0.5)  # मानव-जैसी रुकावट
        await page.fill('input[name="password"]', "password123")

        # कैप्चा हल करें
        print("reCAPTCHA v2 हल कर रहा है...")
        token = await solve_recaptcha_v2(recaptcha_site_key, target_url)
        print(f"टोकन प्राप्त करें: {token[:50]}...")

        # कैप्चा उत्तर क्षेत्र में टोकन इंजेक्ट करें
        await page.evaluate(f'''
            document.getElementById('g-recaptcha-response').innerHTML = '{token}';
            document.getElementById('g-recaptcha-response').style.display = 'block';
        ''')

        # फॉर्म भेजें
        await page.click('button[type="submit"]')
        await page.wait_for_load_state("networkidle")

        print("लॉगिन सफलतापूर्वक!")


if __name__ == "__main__":
    asyncio.run(main())

import asyncio
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "आपका_एपी_कुंजी"
CAPSOLVER_API = "https://api.capsolver.com"


async def solve_recaptcha_v3(
    site_key: str,
    page_url: str,
    action: str = "verify",
    min_score: float = 0.7
) -> str:
    """निर्दिष्ट क्रिया और न्यूनतम स्कोर के साथ reCAPTCHA v3 हल करें।"""
    import httpx

    async with httpx.AsyncClient() as client:
        response = await client.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 = await client.post(
                f"{CAPSOLVER_API}/getTaskResult",
                json={
                    "clientKey": CAPSOLVER_API_KEY,
                    "taskId": task_id
                }
            )
            data = result.json()

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

            await asyncio.sleep(1)


async def main():
    target_url = "https://example.com/search"
    recaptcha_v3_key = "6LcXXXXXXXXXXXXXXXXXXXXXXXXX"

    async with AsyncCamoufox(
        humanize=2.0,  # मानवीय गतिविधि के लिए अधिकतम 2 सेकंड
        headless=True,  # v3 के लिए हेडलेस चलाएं
        geoip=True,  # प्रॉक्सी आईपी से स्वचालित रूप से भू-स्थिति पता करें
    ) as browser:
        page = await browser.new_page()
        await page.goto(target_url)

        # "search" क्रिया के साथ reCAPTCHA v3 हल करें
        print("reCAPTCHA v3 हल कर रहा है...")
        token = await solve_recaptcha_v3(
            recaptcha_v3_key,
            target_url,
            action="search",
            min_score=0.9  # उच्च स्कोर के लिए
        )

        # टोकन के साथ साइट के कॉलबैक के माध्यम से टोकन भेजें
        await page.evaluate(f'''
            // टोकन के साथ कॉलबैक चलाएं
            window['onSubmit']( '{token}' );
        ''')

        # अगला कार्य चलाएं
        await page.click('button[type="submit"]')
        await page.wait_for_load_state("networkidle")

        print("सर्च सफलतापूर्वक!")

    print("reCAPTCHA v3 बच गया!")

---

## श्रेष्ठ व्यवहार

### 1. जियोआईपी के साथ प्रॉक्सी घूमाना

कैमूफॉक्स के जियोआईपी विशेषता का उपयोग करके आप फिंगरप्रिंट को अपने प्रॉक्सी स्थान से स्वचालित रूप से मैच कर सकते हैं:

```python
async with AsyncCamoufox(
    geoip=True,  # प्रॉक्सी आईपी से स्वचालित रूप से निर्धारित करें
    proxy={
        "server": "http://proxy.example.com:8080",
        "username": "user",
        "password": "pass"
    }
) as browser:
    # फिंगरप्रिंट प्रॉक्सी के भौगोलिक स्थान के साथ मैच करेगा
    pass

from browserforge.fingerprints import Screen

# सामान्य स्क्रीन आकारों तक सीमित रखें
screen = Screen(
    min_width=1280,
    max_width=1920,
    min_height=720,
    max_height=1080
)

async with AsyncCamoufox(
    os="windows",
    screen=screen,
) as browser:
    pass

import random

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

# कार्यों के बीच उपयोग करें
await page.click('button')
await human_delay()
await page.fill('input', 'text')

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