使用 CaptchaAI 对跨类型验证码解决时间进行基准测试

解决时间问题。每个解决方案 10 秒的差异会导致数千个任务的延迟数小时。本指南为每种验证码类型提供可重复的基准CaptchaAI支持，以及运行您自己的测量的脚本。

典型求解时间

这些基准反映了每种类型 100 个连续求解的中位时间，从 API 提交到结果检索进行测量：

时间因代理质量、服务器负载和验证码复杂性而异。

影响求解时间的因素

网络延迟

您与 CaptchaAI 的 API 端点的距离会增加往返时间。 200 毫秒 RTT 总共增加约 1 秒（提交 + 3–4 轮询 × 200 毫秒）。

代理质量

使用代理时，自有服务器基础设施通常比数据中心代理产生更快的解决方案，因为它们触发的次要挑战更少。

验证码复杂性

reCAPTCHA v2 图像挑战的难度各不相同。带有褪色图像的“选择交通灯”挑战比简单的复选框验证需要更长的时间。

投票策略

积极的轮询（每 2 秒一次）可以更快地检测结果，但会增加 API 调用。保守轮询（每 10 秒一次）可减少负载，但会增加延迟。

Python 基准脚本

# benchmark_captchaai.py
import os
import time
import statistics
import requests

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

def benchmark_solve(method, params, runs=10):
    """Benchmark a CAPTCHA type over multiple runs."""
    times = []
    successes = 0

    for i in range(runs):
        start = time.time()

        # Submit
        submit_params = {"key": API_KEY, "json": "1", **params}
        resp = requests.get("https://ocr.captchaai.com/in.php",
                            params=submit_params)
        result = resp.json()

        if result.get("status") != 1:
            print(f"  Run {i+1}: Submit failed - {result.get('request')}")
            continue

        task_id = result["request"]

        # Poll
        time.sleep(10)
        solved = False
        for _ in range(30):
            poll = requests.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:
                elapsed = time.time() - start
                times.append(elapsed)
                successes += 1
                solved = True
                print(f"  Run {i+1}: {elapsed:.1f}s")
                break
            if poll_result.get("request") != "CAPCHA_NOT_READY":
                print(f"  Run {i+1}: Error - {poll_result.get('request')}")
                break

            time.sleep(5)

        if not solved and poll_result.get("request") == "CAPCHA_NOT_READY":
            print(f"  Run {i+1}: Timeout")

    if times:
        return {
            "runs": runs,
            "successes": successes,
            "success_rate": f"{successes/runs*100:.0f}%",
            "median": f"{statistics.median(times):.1f}s",
            "p90": f"{sorted(times)[int(len(times)*0.9)]:.1f}s" if len(times) >= 10 else "N/A",
            "min": f"{min(times):.1f}s",
            "max": f"{max(times):.1f}s",
        }
    return {"error": "No successful solves"}

# Benchmark reCAPTCHA v2
print("=== reCAPTCHA v2 ===")
recaptcha_v2 = benchmark_solve("userrecaptcha", {
    "method": "userrecaptcha",
    "googlekey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
    "pageurl": "https://www.google.com/recaptcha/api2/demo",
})
print(recaptcha_v2)

# Benchmark Image/OCR
print("\n=== Image CAPTCHA ===")
# Submit a base64-encoded test image
import base64
# Use a test image for benchmarking
image_result = benchmark_solve("post", {
    "method": "base64",
    "body": "BASE64_ENCODED_CAPTCHA_IMAGE",
})
print(image_result)

JavaScript 基准脚本

// benchmark_captchaai.js
const axios = require('axios');

const API_KEY = process.env.CAPTCHAAI_KEY || 'YOUR_API_KEY';

async function benchmarkSolve(params, runs = 10) {
  const times = [];
  let successes = 0;

  for (let i = 0; i < runs; i++) {
    const start = Date.now();

    // Submit
    const submit = await axios.get('https://ocr.captchaai.com/in.php', {
      params: { key: API_KEY, json: '1', ...params },
    });

    if (submit.data.status !== 1) {
      console.log(`  Run ${i + 1}: Submit failed - ${submit.data.request}`);
      continue;
    }

    // Poll
    await new Promise(r => setTimeout(r, 10000));
    let solved = false;

    for (let j = 0; j < 30; j++) {
      const poll = await axios.get('https://ocr.captchaai.com/res.php', {
        params: { key: API_KEY, action: 'get', id: submit.data.request, json: '1' },
      });

      if (poll.data.status === 1) {
        const elapsed = (Date.now() - start) / 1000;
        times.push(elapsed);
        successes++;
        solved = true;
        console.log(`  Run ${i + 1}: ${elapsed.toFixed(1)}s`);
        break;
      }
      if (poll.data.request !== 'CAPCHA_NOT_READY') {
        console.log(`  Run ${i + 1}: Error - ${poll.data.request}`);
        break;
      }
      await new Promise(r => setTimeout(r, 5000));
    }

    if (!solved) console.log(`  Run ${i + 1}: Timeout`);
  }

  if (times.length === 0) return { error: 'No successful solves' };

  times.sort((a, b) => a - b);
  return {
    runs, successes,
    successRate: `${((successes / runs) * 100).toFixed(0)}%`,
    median: `${times[Math.floor(times.length / 2)].toFixed(1)}s`,
    min: `${times[0].toFixed(1)}s`,
    max: `${times[times.length - 1].toFixed(1)}s`,
  };
}

(async () => {
  console.log('=== reCAPTCHA v2 ===');
  const v2 = await benchmarkSolve({
    method: 'userrecaptcha',
    googlekey: '6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-',
    pageurl: 'https://www.google.com/recaptcha/api2/demo',
  });
  console.log(v2);

  console.log('\n=== Cloudflare Turnstile ===');
  const turnstile = await benchmarkSolve({
    method: 'turnstile',
    sitekey: 'YOUR_TURNSTILE_SITEKEY',
    pageurl: 'https://example.com',
  });
  console.log(turnstile);
})();

解释结果

中位数 vs P90

• 中位数 — 典型体验。将其用于容量规划。
• P90 — 十分之九解决的“最坏情况”。使用它来进行超时设置。
• P99 — 真正的边缘情况。将最大超时设置为高于此值。

最佳轮询间隔

根据上述基准，为每个验证码类型配置轮询：

故障排除

常问问题

解决时间会因一天中的不同时间而变化吗？

是的。由于需求较高，高峰时段（美国营业时间）的解决时间可能会稍长。在不同时间运行基准以获得完整的情况。

我应该使用此数据进行生产超时设置吗？

使用 P90 值表示标准超时，使用 P99 值表示最大超时。添加 20% 的缓冲区以考虑网络变化。

代理设置如何影响求解时间？

如果您提供代理，CaptchaAI 将通过它路由求解。慢速或远程代理可能会使总求解时间增加 5-15 秒。对于基准测试，分别使用和不使用代理进行测试。

相关文章

• 解决多种验证码类型的工作流程
• Captchaai 支持的验证码类型功能矩阵

下一步

针对您自己的帐户和验证码目标运行基准脚本 -获取您的 CaptchaAI API 密钥。

相关指南：

• 优化速度和成本
• CaptchaAI 延迟优化
• 并行验证码求解