Giải quyết CAPTCHA song song và tuần tự: Đánh đổi hiệu suất

Giải quyết tuần tự rất đơn giản. Giải quyết song song là nhanh chóng. Sự lựa chọn đúng đắn phụ thuộc vào khối lượng, cơ sở hạ tầng và khả năng chịu đựng sự phức tạp của bạn. Hướng dẫn này so sánh cả hai cách tiếp cận vớiCaptchaAIvà giúp bạn chọn chiến lược phù hợp.

So sánh trực tiếp

Giải tuần tự

Nó hoạt động như thế nào

Mỗi lần một CAPTCHA: gửi → đợi → thăm dò ý kiến ​​→ nhận kết quả → tiếp theo.

# sequential_solver.py
import os
import time
import requests

API_KEY = os.environ.get("CAPTCHAAI_KEY", "YOUR_API_KEY")

def solve_sequential(tasks):
    """Solve CAPTCHAs one by one."""
    results = []
    session = requests.Session()

    for task in tasks:
        # Submit
        resp = session.get("https://ocr.captchaai.com/in.php", params={
            "key": API_KEY,
            "method": "userrecaptcha",
            "googlekey": task["sitekey"],
            "pageurl": task["pageurl"],
            "json": "1",
        })
        result = resp.json()
        if result.get("status") != 1:
            results.append({"error": result.get("request")})
            continue

        task_id = result["request"]
        time.sleep(15)

        # Poll
        token = None
        for _ in range(25):
            poll = session.get("https://ocr.captchaai.com/res.php", params={
                "key": API_KEY, "action": "get",
                "id": task_id, "json": "1",
            })
            poll_result = poll.json()
            if poll_result.get("status") == 1:
                token = poll_result["request"]
                break
            if poll_result.get("request") != "CAPCHA_NOT_READY":
                break
            time.sleep(5)

        results.append({"token": token} if token else {"error": "timeout"})

    return results

# 10 tasks sequentially → ~150 seconds total
tasks = [{"sitekey": "SITEKEY", "pageurl": "https://example.com"}] * 10
start = time.time()
results = solve_sequential(tasks)
print(f"Completed in {time.time() - start:.0f}s")

Khi tuần tự có ý nghĩa

• Quy trình làm việc trên một trang — Điền vào một biểu mẫu mỗi lần
• Gỡ lỗi và phát triển — Luồng thực thi rõ ràng
• Âm lượng thấp — < 500 giải quyết được/day không biện minh cho sự phức tạp song song
• Nhiệm vụ phụ thuộc vào thứ tự — Khi kết quả giải phải được sử dụng theo trình tự

Giải quyết song song

Nó hoạt động như thế nào

Gửi tất cả CAPTCHA cùng một lúc, thăm dò kết quả đồng thời:

# parallel_solver.py
import os
import asyncio
import aiohttp

API_KEY = os.environ.get("CAPTCHAAI_KEY", "YOUR_API_KEY")

async def solve_one(session, sitekey, pageurl, semaphore):
    """Solve a single CAPTCHA within concurrency limits."""
    async with semaphore:
        # Submit
        async with session.get("https://ocr.captchaai.com/in.php", params={
            "key": API_KEY, "method": "userrecaptcha",
            "googlekey": sitekey, "pageurl": pageurl, "json": "1",
        }) as resp:
            result = await resp.json(content_type=None)

        if result.get("status") != 1:
            return {"error": result.get("request")}

        task_id = result["request"]
        await asyncio.sleep(15)

        # Poll
        for _ in range(25):
            async with session.get("https://ocr.captchaai.com/res.php", params={
                "key": API_KEY, "action": "get",
                "id": task_id, "json": "1",
            }) as resp:
                poll_result = await resp.json(content_type=None)

            if poll_result.get("status") == 1:
                return {"token": poll_result["request"]}
            if poll_result.get("request") != "CAPCHA_NOT_READY":
                return {"error": poll_result.get("request")}

            await asyncio.sleep(5)

        return {"error": "timeout"}

async def solve_parallel(tasks, max_concurrent=50):
    """Solve CAPTCHAs in parallel with concurrency control."""
    semaphore = asyncio.Semaphore(max_concurrent)
    connector = aiohttp.TCPConnector(limit=max_concurrent)

    async with aiohttp.ClientSession(connector=connector) as session:
        coros = [
            solve_one(session, t["sitekey"], t["pageurl"], semaphore)
            for t in tasks
        ]
        return await asyncio.gather(*coros)

# 10 tasks in parallel → ~20 seconds total
import time
tasks = [{"sitekey": "SITEKEY", "pageurl": "https://example.com"}] * 10
start = time.time()
results = asyncio.run(solve_parallel(tasks))
print(f"Completed in {time.time() - start:.0f}s")

Ví dụ song song về JavaScript

// parallel_solver.js
const axios = require('axios');
const https = require('https');

const API_KEY = process.env.CAPTCHAAI_KEY || 'YOUR_API_KEY';
const agent = new https.Agent({ keepAlive: true, maxSockets: 50 });
const api = axios.create({ baseURL: 'https://ocr.captchaai.com', httpsAgent: agent });

async function solveOne(sitekey, pageurl) {
  const submit = await api.get('/in.php', {
    params: { key: API_KEY, method: 'userrecaptcha', googlekey: sitekey, pageurl, json: '1' },
  });
  if (submit.data.status !== 1) return { error: submit.data.request };

  await new Promise(r => setTimeout(r, 15000));

  for (let i = 0; i < 25; i++) {
    const poll = await api.get('/res.php', {
      params: { key: API_KEY, action: 'get', id: submit.data.request, json: '1' },
    });
    if (poll.data.status === 1) return { token: poll.data.request };
    if (poll.data.request !== 'CAPCHA_NOT_READY') return { error: poll.data.request };
    await new Promise(r => setTimeout(r, 5000));
  }
  return { error: 'timeout' };
}

(async () => {
  const tasks = Array.from({ length: 10 }, () => ({
    sitekey: 'SITEKEY', pageurl: 'https://example.com',
  }));

  const start = Date.now();
  const results = await Promise.all(tasks.map(t => solveOne(t.sitekey, t.pageurl)));
  console.log(`Completed in ${((Date.now() - start) / 1000).toFixed(0)}s`);
  console.log(`Solved: ${results.filter(r => r.token).length}/${tasks.length}`);

  agent.destroy();
})();

Thông lượng theo cấp độ đồng thời

Dựa trên reCAPTCHA v2 với thời gian giải trung bình là 15 giây.

Phương pháp lai

Sử dụng tuần tự cho quy trình làm việc và song song để giải CAPTCHA:

# Process 10 URLs sequentially, but solve their CAPTCHAs in a parallel batch
urls = get_next_batch()  # 10 URLs
captcha_params = [extract_sitekey(url) for url in urls]  # Sequential extraction
tokens = asyncio.run(solve_parallel(captcha_params, max_concurrent=10))  # Parallel solving
for url, result in zip(urls, tokens):
    submit_form(url, result.get("token"))  # Sequential submission

Khắc phục sự cố

Câu hỏi thường gặp

Tôi có thể chuyển từ tuần tự sang song song mà không thay đổi cấu trúc mã của mình không?

Có, nếu bạn trích xuất logic giải thành một hàm độc lập. Thay đổi duy nhất là gói cuộc gọi trong asyncio.gather (Python) hoặc Promise.all (JavaScript).

Giải quyết song song có tốn kém hơn không?

Không. CaptchaAI tính phí cho mỗi lần giải chứ không phải cho mỗi yêu cầu đồng thời. Giải quyết song song có cùng chi phí API như tuần tự — bạn chỉ đạt được tổng số nhanh hơn.

Đồng thời thực tế tối đa là gì?

Hầu hết các thiết lập đều đạt lợi nhuận giảm dần trên 100 lần giải quyết đồng thời. Ngoài ra, hãy tập trung vào việc tối ưu hóa các tham số giải thay vì thêm tính đồng thời.

Các bước tiếp theo

Chọn chiến lược phù hợp với khối lượng của bạn —lấy khóa API CaptchaAI của bạn.

Hướng dẫn liên quan:

• Giải quyết CAPTCHA song song
• 10.000 nhiệm vụ mỗi giờ
• Tối ưu hóa bộ nhớ và CPU