Cách giải Captcha trong EasySpider với tích hợp CapSolver

pip install requests

import requests
import time
from typing import Optional
from dataclasses import dataclass

CAPSOLVER_API_KEY = 'YOUR_CAPSOLVER_API_KEY'

@dataclass
class TaskResult:
    status: str
    solution: Optional[dict] = None
    error_description: Optional[str] = None


class CapSolverService:
    def __init__(self, api_key: str = CAPSOLVER_API_KEY):
        self.api_key = api_key
        self.base_url = 'https://api.capsolver.com'

    def create_task(self, task_data: dict) -> str:
        response = requests.post(
            f'{self.base_url}/createTask',
            json={
                'clientKey': self.api_key,
                'task': task_data
            }
        )
        data = response.json()

        if data.get('errorId', 0) != 0:
            raise Exception(f"CapSolver error: {data.get('errorDescription')}")

        return data['taskId']

    def get_task_result(self, task_id: str, max_attempts: int = 60) -> TaskResult:
        for _ in range(max_attempts):
            time.sleep(2)

            response = requests.post(
                f'{self.base_url}/getTaskResult',
                json={
                    'clientKey': self.api_key,
                    'taskId': task_id
                }
            )
            data = response.json()

            if data.get('status') == 'ready':
                return TaskResult(
                    status='ready',
                    solution=data.get('solution')
                )

            if data.get('status') == 'failed':
                raise Exception(f"Task failed: {data.get('errorDescription')}")

        raise Exception('Timeout waiting for CAPTCHA solution')

    def solve_recaptcha_v2(self, website_url: str, website_key: str) -> str:
        task_id = self.create_task({
            'type': 'ReCaptchaV2TaskProxyLess',
            'websiteURL': website_url,
            'websiteKey': website_key
        })

        result = self.get_task_result(task_id)
        return result.solution.get('gRecaptchaResponse', '') if result.solution else ''

    def solve_turnstile(
        self,
        website_url: str,
        website_key: str,
        action: Optional[str] = None,
        cdata: Optional[str] = None
    ) -> str:
        task_data = {
            'type': 'AntiTurnstileTaskProxyLess',
            'websiteURL': website_url,
            'websiteKey': website_key
        }

        if action or cdata:
            metadata = {}
            if action:
                metadata['action'] = action
            if cdata:
                metadata['cdata'] = cdata
            task_data['metadata'] = metadata

        task_id = self.create_task(task_data)
        result = self.get_task_result(task_id)
        return result.solution.get('token', '') if result.solution else ''


# Thực thể toàn cục
capsolver = CapSolverService()

// Trích xuất sitekey từ phần tử reCAPTCHA
var siteKey = document.querySelector('.g-recaptcha').getAttribute('data-sitekey');
var pageUrl = window.location.href;

// Lưu trữ để sử dụng trong bước tiếp theo
window.captchaSiteKey = siteKey;
window.captchaPageUrl = pageUrl;

// Ghi nhật ký để gỡ lỗi
console.log('Site Key:', siteKey);
console.log('Page URL:', pageUrl);

// Token sẽ được truyền từ script bên ngoài
var token = arguments[0];  // Được truyền từ EasySpider

// Hiển thị ô văn bản phản hồi và đặt token
document.getElementById('g-recaptcha-response').style.display = 'block';
document.getElementById('g-recaptcha-response').value = token;

// Nếu có hàm gọi lại, thực thi nó
if (typeof ___grecaptcha_cfg !== 'undefined') {
    var clients = ___grecaptcha_cfg.clients;
    if (clients) {
        Object.keys(clients).forEach(function(key) {
            var client = clients[key];
            if (client.callback) {
                client.callback(token);
            }
        });
    }
}

// Tiêu đề nút: TS_SiteKey
return document.querySelector('.cf-turnstile')?.getAttribute('data-sitekey') || '';

// Tiêu đề nút: TS_Action (tùy chọn)
return document.querySelector('.cf-turnstile')?.getAttribute('data-action') || '';

// Tiêu đề nút: TS_Cdata (tùy chọn)
return document.querySelector('.cf-turnstile')?.getAttribute('data-cdata') || '';

python captcha_solver.py "{{current_url}}" "Field[\"TS_SiteKey\"]" "turnstile" "Field[\"TS_Action\"]" "Field[\"TS_Cdata\"]"

var token = `Field["Token"]`;
var inputs = document.querySelectorAll('input[name="cf-turnstile-response"], input[name="turnstile-response"]');
inputs.forEach(function(el) {
    el.value = token;
    el.dispatchEvent(new Event('input', { bubbles: true }));
    el.dispatchEvent(new Event('change', { bubbles: true }));
});

# Thêm vào đầu easyspider_executestage.py
import requests
import time

# Thêm lớp CapSolver
class CapSolverService:
    # ... (thực hiện từ trên)
    pass

# Tạo thực thể toàn cục
capsolver = CapSolverService('YOUR_CAPSOLVER_API_KEY')

# Bây giờ capsolver.solve_recaptcha_v2() có sẵn trong các khối eval/exec

# Trong khối thực thi Python của EasySpider
site_key = driver.find_element_by_class_name('g-recaptcha').get_attribute('data-sitekey')
token = capsolver.solve_recaptcha_v2(current_url, site_key)
driver.execute_script(f'''
    document.getElementById('g-recaptcha-response').value = `{token}`;
''')

import time
from functools import wraps
from typing import Callable, TypeVar, Any

T = TypeVar('T')

def retry(max_retries: int = 3, exponential_backoff: bool = True):
    """Giao diện logic thử lại với backoff theo cấp số nhân."""
    def decorator(func: Callable[..., T]) -> Callable[..., T]:
        @wraps(func)
        def wrapper(*args: Any, **kwargs: Any) -> T:
            last_exception = None

            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    last_exception = e

                    if attempt < max_retries - 1:
                        delay = (2 ** attempt) if exponential_backoff else 1
                        print(f'Attempt {attempt + 1} failed, retrying in {delay}s...')
                        time.sleep(delay)

            raise last_exception

        return wrapper
    return decorator


@retry(max_retries=3, exponential_backoff=True)
def solve_with_retry(capsolver, url: str, site_key: str) -> str:
    return capsolver.solve_recaptcha_v2(url, site_key)

def check_balance(api_key: str) -> float:
    response = requests.post(
        'https://api.capsolver.com/getBalance',
        json={'clientKey': api_key}
    )
    data = response.json()
    return data.get('balance', 0)


def main():
    balance = check_balance(CAPSOLVER_API_KEY)

    if balance < 1:
        print('Cảnh báo: Số dư CapSolver thấp! Vui lòng nạp tiền.')
    else:
        print(f'Số dư hiện tại: ${balance:.2f}')

# Thực thi cơ bản
python easyspider_executestage.py --id [task_id] --read_type local --headless 1

# Với các tham số đầy đủ
python easyspider_executestage.py \
    --ids [0] \
    --server_address http://localhost:8074 \
    --config_folder "./" \
    --headless 1 \
    --read_type local

#!/usr/bin/env python3
"""
Script Hỗ trợ CapSolver cho EasySpider
Cách sử dụng: python captcha_solver.py <url> <site_key> <loại_captcha> [hành động] [cdata]
"""

import sys
import requests
import time

CAPSOLVER_API_KEY = 'YOUR_CAPSOLVER_API_KEY'

def solve_captcha(url, site_key, captcha_type='recaptcha_v2', action=None, cdata=None):
    """Giải CAPTCHA và trả về token."""

    if captcha_type == 'recaptcha_v2':
        task_type = 'ReCaptchaV2TaskProxyLess'
    elif captcha_type == 'turnstile':
        task_type = 'AntiTurnstileTaskProxyLess'
    else:
        raise ValueError(f'Loại CAPTCHA không biết: {captcha_type}')

    # Tạo nhiệm vụ
    task = {
        'type': task_type,
        'websiteURL': url,
        'websiteKey': site_key
    }
    if captcha_type == 'turnstile' and (action or cdata):
        metadata = {}
        if action:
            metadata['action'] = action
        if cdata:
            metadata['cdata'] = cdata
        task['metadata'] = metadata

    response = requests.post(
        'https://api.capsolver.com/createTask',
        json={
            'clientKey': CAPSOLVER_API_KEY,
            'task': task
        }
    )
    data = response.json()

    if data.get('errorId', 0) != 0:
        raise Exception(f"Lỗi: {data.get('errorDescription')}")

    task_id = data['taskId']

    # Kiểm tra kết quả
    for _ in range(60):
        time.sleep(2)

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

        if data.get('status') == 'ready':
            solution = data.get('solution', {})
            return solution.get('gRecaptchaResponse') or solution.get('token')

        if data.get('status') == 'failed':
            raise Exception(f"Thất bại: {data.get('errorDescription')}")

    raise Exception('Hết thời gian')


if __name__ == '__main__':
    if len(sys.argv) < 3:
        print('Cách sử dụng: python captcha_solver.py <url> <site_key> [loại_captcha] [hành động] [cdata]')
        sys.exit(1)

    url = sys.argv[1]
    site_key = sys.argv[2]
    captcha_type = sys.argv[3] if len(sys.argv) > 3 else 'recaptcha_v2'
    action = sys.argv[4] if len(sys.argv) > 4 else None
    cdata = sys.argv[5] if len(sys.argv) > 5 else None

    try:
        token = solve_captcha(url, site_key, captcha_type, action, cdata)
        print(token)  # Xuất token để EasySpider bắt giữ
    except Exception as e:
        print(f'LỖI: {e}', file=sys.stderr)
        sys.exit(1)

python captcha_solver.py "{{current_url}}" "{{site_key}}" "recaptcha_v2"

python captcha_solver.py "{{current_url}}" "{{site_key}}" "turnstile" "{{action}}" "{{cdata}}"