Node.js Promise.allSettled 用于批量验证码解决

批量提交验证码识别任务时，很多人默认用 Promise.all——直到第 37 个任务抛错，前面 36 个成功结果一起报废。Promise.all 一个失败就整体拒绝；Promise.allSettled 等每个都跑完，成败都还给你。批量识别该用后者。

本文这套实现覆盖：

• 提交 + 轮询的完整 solveCaptcha，可直接接入你的批量脚本
• 并发限制 worker pool，避免一次性打爆连接池
• 失败任务自动重试，暂时性错误和永久性错误分开处理
• 实时进度打印，几分钟的批量任务不再是黑盒

Promise.all 与 Promise.allSettled 的区别

两者的核心差异，一段代码就能看清楚：

// Promise.all — REJECTS if ANY task fails
const results = await Promise.all(tasks.map(solve)); // Throws on first error

// Promise.allSettled — RESOLVES always, with status for each
const results = await Promise.allSettled(tasks.map(solve));
// [{status: "fulfilled", value: "..."}, {status: "rejected", reason: Error}]

核心实现：提交、轮询、批量整合

下面的代码封装单个任务的生命周期——提交到 in.php，每 5 秒轮询 res.php，拿到 token 或超时；batchSolve 用 Promise.allSettled 整理出成功和失败两个数组：

const axios = require("axios");

const API_KEY = process.env.CAPTCHAAI_API_KEY;

function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

async function solveCaptcha(sitekey, pageurl) {
  // Submit
  const submitResp = await axios.post(
    "https://ocr.captchaai.com/in.php",
    null,
    {
      params: {
        key: API_KEY,
        method: "userrecaptcha",
        googlekey: sitekey,
        pageurl: pageurl,
        json: 1,
      },
    }
  );

  if (submitResp.data.status !== 1) {
    throw new Error(submitResp.data.request);
  }

  const captchaId = submitResp.data.request;

  // Poll
  for (let i = 0; i < 60; i++) {
    await sleep(5000);
    const result = await axios.get("https://ocr.captchaai.com/res.php", {
      params: { key: API_KEY, action: "get", id: captchaId, json: 1 },
    });

    if (result.data.status === 1) return result.data.request;
    if (result.data.request !== "CAPCHA_NOT_READY") {
      throw new Error(result.data.request);
    }
  }

  throw new Error("TIMEOUT");
}

async function batchSolve(tasks) {
  const promises = tasks.map((task) =>
    solveCaptcha(task.sitekey, task.pageurl).then((solution) => ({
      ...task,
      solution,
    }))
  );

  const results = await Promise.allSettled(promises);

  const solved = [];
  const failed = [];

  for (let i = 0; i < results.length; i++) {
    if (results[i].status === "fulfilled") {
      solved.push(results[i].value);
    } else {
      failed.push({
        task: tasks[i],
        error: results[i].reason.message,
      });
    }
  }

  return { solved, failed };
}

// Usage
(async () => {
  const tasks = [
    {
      sitekey: "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
      pageurl: "https://example.com/page/1",
    },
    {
      sitekey: "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
      pageurl: "https://example.com/page/2",
    },
    {
      sitekey: "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
      pageurl: "https://example.com/page/3",
    },
  ];

  const { solved, failed } = await batchSolve(tasks);
  console.log(`Solved: ${solved.length}, Failed: ${failed.length}`);

  for (const s of solved) {
    console.log(`  ✓ ${s.pageurl}: ${s.solution.substring(0, 30)}...`);
  }
  for (const f of failed) {
    console.log(`  ✗ ${f.task.pageurl}: ${f.error}`);
  }
})();

控制并发数，避免连接过载

同时发 1,000 个请求会压垮连接池，用并发限制器控制同时在跑的任务数更稳妥：

async function batchSolveWithLimit(tasks, concurrency = 10) {
  const results = [];
  let index = 0;

  async function worker() {
    while (index < tasks.length) {
      const i = index++;
      const task = tasks[i];

      try {
        const solution = await solveCaptcha(task.sitekey, task.pageurl);
        results[i] = { status: "fulfilled", value: { ...task, solution } };
      } catch (err) {
        results[i] = { status: "rejected", reason: err };
      }
    }
  }

  // Launch concurrent workers
  const workers = Array.from({ length: concurrency }, () => worker());
  await Promise.allSettled(workers);

  const solved = results
    .filter((r) => r.status === "fulfilled")
    .map((r) => r.value);
  const failed = results
    .filter((r) => r.status === "rejected")
    .map((r, i) => ({ task: tasks[i], error: r.reason.message }));

  return { solved, failed };
}

// Solve 100 CAPTCHAs, 10 at a time
const { solved, failed } = await batchSolveWithLimit(tasks, 10);

concurrency 只是节流阀，真正上限来自 CaptchaAI 套餐线程数：

• BASIC（$15/月，5 线程）：本地联调够用
• STANDARD（$30/月，15 线程）：中等批量任务
• ADVANCE（$90/月，50 线程）：大批量首选

经验值：把 concurrency 设为线程数的 60%-80%，给网络抖动留缓冲，比直接跑满更稳。

自动重试失败任务

大部分失败是暂时性的，重试就过；永久性错误（sitekey 填错之类）重试也没用，先分类：

async function batchSolveWithRetry(tasks, maxRetries = 2, concurrency = 10) {
  let currentTasks = [...tasks];
  let allSolved = [];

  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    if (currentTasks.length === 0) break;

    console.log(
      `Attempt ${attempt + 1}: solving ${currentTasks.length} tasks...`
    );

    const { solved, failed } = await batchSolveWithLimit(
      currentTasks,
      concurrency
    );

    allSolved = [...allSolved, ...solved];

    // Only retry transient errors
    const retryable = failed.filter(
      (f) =>
        f.error === "TIMEOUT" ||
        f.error === "ERROR_NO_SLOT_AVAILABLE" ||
        f.error === "ERROR_TOO_MUCH_REQUESTS"
    );

    currentTasks = retryable.map((f) => f.task);

    if (retryable.length > 0) {
      console.log(`  Retrying ${retryable.length} failed tasks...`);
    }
  }

  const finalFailed = currentTasks; // Anything left after all retries
  return { solved: allSolved, failed: finalFailed };
}

TIMEOUT、ERROR_NO_SLOT_AVAILABLE、ERROR_TOO_MUCH_REQUESTS 是典型的暂时性错误，值得重试；其余错误直接进 finalFailed。

实时进度追踪

批量任务动辄跑几分钟，不如打印实时进度：

async function batchSolveWithProgress(tasks, concurrency = 10) {
  let completed = 0;
  let succeeded = 0;
  let failed = 0;

  const wrapped = tasks.map((task) =>
    solveCaptcha(task.sitekey, task.pageurl)
      .then((solution) => {
        succeeded++;
        completed++;
        process.stdout.write(
          `\rProgress: ${completed}/${tasks.length} (${succeeded} ok, ${failed} err)`
        );
        return { ...task, solution };
      })
      .catch((err) => {
        failed++;
        completed++;
        process.stdout.write(
          `\rProgress: ${completed}/${tasks.length} (${succeeded} ok, ${failed} err)`
        );
        throw err;
      })
  );

  const results = await Promise.allSettled(wrapped);
  console.log("\nDone.");
  return results;
}

结果分类：区分可重试与不可重试错误

拿到结果后，整理成可落库或告警的结构：

function categorizeResults(settled, originalTasks) {
  const categories = {
    solved: [],
    transientErrors: [],
    permanentErrors: [],
  };

  const TRANSIENT = new Set([
    "TIMEOUT",
    "ERROR_NO_SLOT_AVAILABLE",
    "ERROR_TOO_MUCH_REQUESTS",
  ]);

  for (let i = 0; i < settled.length; i++) {
    const r = settled[i];
    if (r.status === "fulfilled") {
      categories.solved.push(r.value);
    } else {
      const error = r.reason.message;
      const entry = { task: originalTasks[i], error };

      if (TRANSIENT.has(error)) {
        categories.transientErrors.push(entry);
      } else {
        categories.permanentErrors.push(entry);
      }
    }
  }

  return categories;
}

transientErrors 丢回重试队列，permanentErrors 人工复查。混了国内 GeeTest（极验）和海外 reCAPTCHA、Turnstile 的批量任务，这套分类同样适用。

值得记住的暂时性错误清单：

• TIMEOUT：轮询到超时上限还没拿到结果
• ERROR_NO_SLOT_AVAILABLE：并发超过了套餐线程配额
• ERROR_TOO_MUCH_REQUESTS：短时间内请求过于密集

故障排查

先看两件事：日志里的错误信息，以及并发数和套餐线程数是否匹配——大多数问题都出在这两处。

常见问题

并发数设多高才不会被限流？

从 10 起步，往上加到收益变小或错误率上升为止。真正上限是套餐线程数，线程用满了加并发也只是排队。

频繁出现 ERROR_NO_SLOT_AVAILABLE 怎么办？

说明并发超过了线程配额，先调低 concurrency，仍不够再升级线程数更高的套餐。

能在一次批量任务里混合不同类型的验证码吗？

可以，solveCaptcha 只靠 method 区分类型，batchSolve 不关心任务内部具体是哪种。

和异步生成器或流式处理比，怎么选？

Promise.allSettled 适合一次性提交一批、等结果；无尽头的连续任务流（如无限翻页抓取）更适合异步生成器或队列 worker pool。

maxRetries 设几次比较合适？

2 次通常够了：第一次覆盖大部分暂时性抖动，第二次兜底。超过 3 次收益很小，反而拉长整体耗时，遇到还在失败的任务不如直接进 permanentErrors 人工看一眼。

下一步

先把并发和重试做对——获取你的 CaptchaAI API 密钥，用上面的代码跑一批试试。

相关指南：

• 并行验证码识别怎么做
• 批量验证码解决：多任务实践
• 每小时处理 10,000 个任务