Cara mengintegrasikan Camoufox dengan CapSolver untuk menyelesaikan CAPTCHA yang mulus

# Instal paket Python
pip install -U camoufox[geoip]

# Unduh browser Camoufox
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 = "KUNCI_API_ANDA"
CAPSOLVER_API = "https://api.capsolver.com"


async def create_task(task_payload: dict) -> str:
    """Membuat tugas penyelesaian CAPTCHA dan mengembalikan ID tugas."""
    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"Kesalahan CapSolver: {result.get('errorDescription')}")
        return result["taskId"]


async def get_task_result(task_id: str, max_attempts: int = 120) -> dict:
    """Memantau hasil tugas hingga selesai atau timeout."""
    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"Tugas gagal: {result.get('errorDescription')}")

            await asyncio.sleep(1)

    raise TimeoutError("Penyelesaian CAPTCHA melebihi waktu yang diberikan")


async def solve_captcha(task_payload: dict) -> dict:
    """Menyelesaikan alur kerja CAPTCHA."""
    task_id = await create_task(task_payload)
    return await get_task_result(task_id)

from camoufox.sync_api import Camoufox

with Camoufox(
    addons=["/path/to/capsolver-extension"],
    headless=False  # Ekstensi memerlukan mode yang terlihat
) as browser:
    page = browser.new_page()
    # Ekstensi akan secara otomatis mendeteksi dan menyelesaikan CAPTCHA

import asyncio
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "KUNCI_API_ANDA"
CAPSOLVER_API = "https://api.capsolver.com"


async def solve_turnstile(site_key: str, page_url: str) -> str:
    """Menyelesaikan Cloudflare Turnstile dan mengembalikan token."""
    import httpx

    async with httpx.AsyncClient() as client:
        # Membuat tugas
        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"]

        # Memantau hasil
        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"  # Temukan ini di sumber halaman

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

        # Menunggu Turnstile dimuat
        await page.wait_for_selector('input[name="cf-turnstile-response"]', timeout=10000)

        # Menyelesaikan CAPTCHA
        token = await solve_turnstile(turnstile_site_key, target_url)
        print(f"Dapatkan token Turnstile: {token[:50]}...")

        # Menyuntikkan token
        await page.evaluate(f'''
            document.querySelector('input[name="cf-turnstile-response"]').value = "{token}";

            // Juga atur callback tersembunyi jika ada
            const callback = document.querySelector('[data-callback]');
            if (callback) {{
                const callbackName = callback.getAttribute('data-callback');
                if (window[callbackName]) {{
                    window[callbackName]('{token}');
                }}
            }}
        ''')

        # Mengirim formulir
        await page.click('button[type="submit"]')
        await page.wait_for_load_state("networkidle")

        print("Berhasil melewati Turnstile!")


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

import asyncio
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "KUNCI_API_ANDA"
CAPSOLVER_API = "https://api.capsolver.com"


async def solve_recaptcha_v2(site_key: str, page_url: str) -> str:
    """Menyelesaikan reCAPTCHA v2 dan mengembalikan token."""
    import httpx

    async with httpx.AsyncClient() as client:
        # Membuat tugas
        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"Kesalahan: {result.get('errorDescription')}")

        task_id = result["taskId"]

        # Memantau hasil
        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"Gagal: {data.get('errorDescription')}")

            await asyncio.sleep(2)


async def main():
    target_url = "https://example.com/login"
    recaptcha_site_key = "6LcXXXXXXXXXXXXXXXXXXXXXXXXX"  # Temukan di sumber halaman

    async with AsyncCamoufox(
        humanize=True,
        headless=False,
        os=["windows", "macos"]  # Pemilihan OS acak
    ) as browser:
        page = await browser.new_page()
        await page.goto(target_url)

        # Mengisi bidang formulir dengan jeda mirip manusia
        await page.fill('input[name="username"]', "user@example.com")
        await asyncio.sleep(0.5)  # Jeda mirip manusia
        await page.fill('input[name="password"]', "password123")

        # Menyelesaikan CAPTCHA
        print("Menyelesaikan reCAPTCHA v2...")
        token = await solve_recaptcha_v2(recaptcha_site_key, target_url)
        print(f"Dapatkan token: {token[:50]}...")

        # Menyuntikkan token ke bidang respons reCAPTCHA
        await page.evaluate(f'''
            document.getElementById('g-recaptcha-response').innerHTML = '{token}';
            document.getElementById('g-recaptcha-response').style.display = 'block';
        ''')

        # Mengirim formulir
        await page.click('button[type="submit"]')
        await page.wait_for_load_state("networkidle")

        print("Login berhasil!")


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

import asyncio
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "KUNCI_API_ANDA"
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:
    """Menyelesaikan reCAPTCHA v3 dengan aksi dan skor minimum yang ditentukan."""
    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"Kesalahan: {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"Gagal: {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,  # Gerakan kursor maksimal 2 detik
        headless=True,  # Bisa dijalankan dalam mode tanpa antarmuka untuk v3
        geoip=True,  # Deteksi geolokasi otomatis dari proxy
    ) as browser:
        page = await browser.new_page()
        await page.goto(target_url)

        # Menyelesaikan reCAPTCHA v3 dengan aksi "search"
        print("Menyelesaikan reCAPTCHA v3...")
        token = await solve_recaptcha_v3(
            recaptcha_v3_key,
            target_url,
            action="search",
            min_score=0.9  # Meminta skor tinggi
        )

        # Menjalankan callback dengan token
        await page.evaluate(f'''
            // Kirim token melalui callback situs

    print("reCAPTCHA v3 berhasil dihindari!")

---

## Praktik Terbaik

### 1. Rotasi Proxy dengan GeoIP

Gunakan fitur GeoIP Camoufox untuk secara otomatis menyesuaikan sidik jari dengan lokasi proxy Anda:

```python
async with AsyncCamoufox(
    geoip=True,  # Deteksi otomatis dari IP proxy
    proxy={
        "server": "http://proxy.example.com:8080",
        "username": "user",
        "password": "pass"
    }
) as browser:
    # Sidik jari akan menyesuaikan lokasi geografis proxy
    pass

from browserforge.fingerprints import Screen

# Batasi ke ukuran layar umum
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 jeda_manusia():
    """Jeda acak untuk meniru perilaku manusia."""
    await asyncio.sleep(random.uniform(1.0, 3.0))

# Gunakan antara tindakan
await page.click('button')
await jeda_manusia()
await page.fill('input', 'text')

async def selesaikan_dengan_pengulangan(payload_tugas: dict, maks_pengulangan: int = 3) -> dict:
    """Selesaikan CAPTCHA dengan logika pengulangan."""
    for percobaan in range(maks_pengulangan):
        try:
            return await selesaikan_captcha(payload_tugas)
        except TimeoutError:
            if percobaan < maks_pengulangan - 1:
                print(f"Timeout, mencoba lagi... ({percobaan + 1}/{maks_pengulangan})")
                await asyncio.sleep(5)
            else:
                raise
        except Exception as e:
            if "saldo" in str(e).lower():
                raise  # Jangan ulangi kesalahan saldo
            if percobaan < maks_pengulangan - 1:
                await asyncio.sleep(2)
            else:
                raise