---
title: "没有 Batch API 如何批量调用大模型：执行器与耗时估算 | BroadRouter"
description: "不用 Batch API，也能用 chat completions 接口跑完 1 万到 100 万条提示词：并发上限、速率控制、重试、可续跑的检查点，以及耗时怎么算。"
url: https://broadrouter.com/zh/blog/llm-batch-processing-without-batch-api/
lang: zh-Hans
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

本页由英文原文借助 AI 翻译。 [阅读英文原文](https://broadrouter.com/blog/llm-batch-processing-without-batch-api/) (2026-11-16 更新).

# 没有 Batch API 也能批量调用大模型：可断点续跑的执行器

BroadNet Inference 团队 · 阅读约 8 分钟 · 发布于 2026-11-15 · 更新于 2026-11-16

没有 Batch API 时，就自己跑任务：从 JSONL 文件读取条目，把同时进行的请求数限制在密钥的并发上限内，按每分钟限额控制请求的发起节奏，对 429 和 5xx 做有上限的退避重试，并把每条结果连同 ID 追加写入文件。重启时跳过已完成的 ID。决定完成时间的通常是速率限制，而不是模型。

## 要点

-   BroadNet Inference 只提供 chat completions 和转写接口。没有 Batch API，也没有批量折扣，所以批量任务就是一个循环发送普通请求的过程。
-   完成时间 = 条目数 ÷ 两个速率中较慢的那个：并发上限 ÷ 延迟，或每分钟请求数。按量付费密钥允许同时 4 个请求、每分钟 30 个，所以每个请求一条时，每天最多 43,200 条。
-   每个条目写一行结果，以 ID 为键，并立即 flush。这一行就是检查点：崩溃最多损失当时正在进行的请求。
-   套餐会话一次只运行一个请求。每个会话每天的吞吐量是 86,400 ÷ 你实测的每条秒数。
-   如果任务可以等一天，而 50% 的批量折扣对你很重要，OpenAI 和 Anthropic 的 Batch API 可能更便宜。两种方案都算一下价格。

**本页内容**

1.  BroadNet Inference 有 Batch API 吗？
2.  任务要跑多久？
3.  可断点续跑的执行器长什么样？
4.  为什么用 worker 池，而不是 asyncio.gather？
5.  重试怎样才安全？
6.  检查点是怎么工作的？
7.  成本多少：按量付费还是套餐会话？
8.  BroadNet Inference 处在什么位置

有些大模型任务不是聊天。你有 5 万张客服工单要打标签，20 万条商品描述要翻译，或者一百万条评论要打分。OpenAI 和 Anthropic 等服务商为此提供了 [Batch API](https://broadrouter.com/zh/glossary/batch-api/)。很多 OpenAI 兼容 API 没有，BroadNet Inference 就是其中之一。本文介绍如何自己跑这类任务：估算需要多长时间，写一个遵守限制的执行器，并让它可以安全地停止和重启。

BroadRouter 是 BroadNet 自己的网站，所以示例中的数字使用 BroadNet 公布的限制。这个方法适用于任何 chat completions API；换成你的服务商的数字即可。

## BroadNet Inference 有 Batch API 吗？

没有。截至 2026 年 11 月 15 日，[API 参考](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=zh-blog-llm-batch-processing-without-batch-api&utm_content=body)列出了 `POST /v1/chat/completions`、`POST /v1/audio/transcriptions` 和 `GET /v1/models`（模型列表），以及 `/portal/` 下的账户接口。没有批量或文件上传接口，也没有批量折扣。批量任务就是一个循环发送普通请求的过程。

下面是托管 Batch API 提供的东西，这样你就知道自己要重建什么：

|  | OpenAI Batch API | Anthropic Message Batches | 你自己的执行器 |
| --- | --- | --- | --- |
| 价格 | 同步价格的 5 折 | 5 折 | 正常价格 |
| 完成时间 | 24 小时内 | 大多数 1 小时内；24 小时后过期 | 取决于你的速率限制 |
| 每批大小 | 50,000 个请求或 200 MB | 100,000 个请求或 256 MB | 任意大小 |
| 速率限制 | 与各模型的限制分开 | 适用于排队中的请求 | 你的密钥的限制 |
| 结果顺序 | 可能不同；按 `custom_id` 匹配 | 按 `custom_id` 匹配 | 你按 ID 存放结果 |

有两点经验可以照搬。两家服务商都要求你给每个请求打上 ID，因为结果不会按顺序返回。两家都不承诺几秒内给出答案。你的执行器也应该这样：所有东西都带 ID，计划以小时为单位。

如果 50% 的折扣比完成时间更重要，而且你需要的模型那里也有，托管的 Batch API 可能更便宜。动手之前，用 [LLM API 成本计算器](https://broadrouter.com/tools/llm-api-cost-calculator/)把两种方案都算一下。

## 任务要跑多久？

写代码之前先算清楚。有两个限制会卡住吞吐量，以较慢的那个为准：

-   **并发上限 ÷ 延迟。** 同时 4 个请求、每个请求 2 秒，你每秒能完成 2 个。
-   **每分钟请求数。** 每分钟 30 个，你每秒只能发起 0.5 个，无论模型有多快。

BroadNet 的[按量付费](https://broadrouter.com/zh/glossary/pay-as-you-go/)密钥允许同时 4 个请求、每分钟 30 个。按我们查看时 API 参考中的数值（每分钟 30 个、同时 4 个，2026-11-15），除非每个请求超过 8 秒，否则起作用的是[速率限制](https://broadrouter.com/zh/glossary/rate-limit/)。下表按每分钟 30 个计算：

| 条目数 | 每个请求一条 | 每个请求 20 条 |
| --- | --- | --- |
| 10,000 | 5.6 小时 | 17 分钟 |
| 100,000 | 2.3 天 | 2.8 小时 |
| 1,000,000 | 23 天 | 28 小时 |

每分钟 30 个请求，一个密钥每小时能发 1,800 个请求，每天 43,200 个。重试也要算进去：你触发的每个 429 都会占掉一个名额。

第二列是最大的杠杆。短条目，比如评论或工单标题，可以每个请求放 10 到 50 条，以编号列表发送，返回一个 JSON 数组。检查数组是否每个输入都有一项，且每项都带着自己的编号。[阿拉伯语文本分类一文](https://broadrouter.com/zh/blog/arabic-text-classification-llm/)展示了这种写法。长条目没法打包：每个请求仍然要放得进模型的[上下文窗口](https://broadrouter.com/zh/glossary/context-window/)，而且列表越长质量可能越差。信任打包之前，先用 200 条测试一下。

不要未经询问就把一个任务分散到多个密钥上，以突破单密钥限制。BroadNet 的[可接受使用政策](https://www.broadnet.ai/aup)禁止规避速率、并发或预算限制。如果你需要更多，请询问 BroadNet，或者使用下文介绍的套餐会话。[批量任务规划器](https://broadrouter.com/tools/llm-batch-job-planner/)会根据你的条目数、延迟和限制来做这笔算术。

## 可断点续跑的执行器长什么样？

这个执行器读取 `items.jsonl`（每行一个 `{"id", "text"}` 对象），并为每个条目向 `results.jsonl` 追加一行结果。它只需要 OpenAI Python SDK。

```python
import asyncio, json, os, random, time
from openai import AsyncOpenAI, APIStatusError, APIConnectionError, APITimeoutError

client = AsyncOpenAI(base_url=os.environ.get("BASE_URL", "https://inference.broadnet.ai/v1"),
                     api_key=os.environ["BROADNET_API_KEY"],
                     max_retries=0,        # we retry ourselves, with a cap we can see
                     timeout=120)
MODEL = os.environ.get("MODEL", "broadnet/deepseek-v4.1-flash")
IN_FLIGHT = int(os.environ.get("IN_FLIGHT", "4"))     # PAYG key: 4 in flight. Plan: 1 per session.
RPM = int(os.environ.get("RPM", "30"))                # PAYG key: 30 requests a minute
MAX_ATTEMPTS = 6

class Pacer:
    """Spaces request starts at least 60/RPM seconds apart, across all workers."""
    def __init__(self, rpm):
        self.gap, self.next, self.lock = 60 / rpm, 0.0, asyncio.Lock()
    async def wait(self):
        async with self.lock:
            now = time.monotonic()
            delay = max(0.0, self.next - now)
            self.next = max(now, self.next) + self.gap
        await asyncio.sleep(delay)

def retryable(e):
    if isinstance(e, (APIConnectionError, APITimeoutError)):
        return True
    return isinstance(e, APIStatusError) and e.status_code in (429, 500, 502, 503, 504)

async def call(item, pacer):
    for attempt in range(MAX_ATTEMPTS):
        await pacer.wait()                          # every attempt counts against the rate limit
        try:
            r = await client.chat.completions.create(
                model=MODEL, max_tokens=1500, reasoning_effort="low",
                messages=[{"role": "system", "content": "Classify the review as positive, negative or mixed. Reply with one word."},
                          {"role": "user", "content": item["text"]}])
            c = r.choices[0]
            return {"id": item["id"], "ok": True, "finish_reason": c.finish_reason,
                    "output": c.message.content, "usage": r.usage.model_dump() if r.usage else None}
        except Exception as e:
            if not retryable(e) or attempt == MAX_ATTEMPTS - 1:
                return {"id": item["id"], "ok": False, "error": repr(e)[:300]}
            await asyncio.sleep(random.uniform(0, min(60, 2 ** attempt)))   # full jitter, capped

async def run(in_path, out_path):
    done = set()
    if os.path.exists(out_path):                    # resume: skip ids that already succeeded
        with open(out_path) as f:
            done = {json.loads(l)["id"] for l in f if l.strip() and json.loads(l).get("ok")}
    todo = [it for it in map(json.loads, open(in_path)) if it["id"] not in done]
    print(f"{len(done)} done, {len(todo)} to go")
    pacer, queue = Pacer(RPM), asyncio.Queue()
    for it in todo:
        queue.put_nowait(it)
    with open(out_path, "a") as out:
        async def worker():
            while True:
                try:
                    it = queue.get_nowait()
                except asyncio.QueueEmpty:
                    return
                res = await call(it, pacer)
                out.write(json.dumps(res, ensure_ascii=False) + "\n")
                out.flush()                         # one line per finished item = the checkpoint
        await asyncio.gather(*(worker() for _ in range(IN_FLIGHT)))

if __name__ == "__main__":
    import sys
    asyncio.run(run(sys.argv[1], sys.argv[2]))
```

用 `python batch_run.py items.jsonl results.jsonl` 运行。我们用这个文件原样测试过一个本地模拟服务器，它会随机返回 429（8%）和 500（5%），并拒绝任何超过同时 4 个或每分钟 30 次发起的请求。25 个条目在 55 秒内完成，共 28 个请求（3 次重试），任何 60 秒窗口内的发起次数都没有超过 30 次。为节省时间把模拟服务器的限制提高到每分钟 300 次后，一个 120 条的任务在 10 秒后被强行终止，重启时从已保存的 39 条结果继续，最终得到 120 个不重复的 ID，没有重复项。

## 为什么用 worker 池，而不是 asyncio.gather？

[429 指南](https://broadrouter.com/zh/blog/handle-llm-api-429-rate-limits/)在 `asyncio.gather` 外面套了一个信号量。几百次调用这样做没问题。对于大任务，固定数量的 worker 从队列中取任务更好：

-   **内存。** `gather` 一开始就为每个条目创建一个任务。worker 池只持有正在进行的条目。
-   **并发数就是池的大小。** 四个 worker 永远不可能同时打开五个请求。
-   **结果随完成随写入磁盘**，顺序不限，以 ID 为键。

`Pacer` 负责第二个限制。单靠信号量只能保证同时不超过 4 个，但如果每个请求只要一秒，四个 worker 每分钟会发起 240 个请求，其中大部分都会碰到 429。pacer 让所有 worker 的请求发起间隔至少 2 秒，重试也算在内。

## 重试怎样才安全？

只重试那些第二次有可能成功的请求：

| 响应 | 处理方式 |
| --- | --- |
| 429 | 退避后重试；BroadNet 的文档写道 “use response details and bounded backoff”（译文：利用响应详情并使用有上限的退避） |
| 500、502、503、504、超时、连接中断 | 用有上限的指数退避重试 |
| 400、422 | 修正请求；重试只会得到同样的错误 |
| 401、402、403 | 停止任务；密钥、余额或策略需要处理 |
| 413 | 缩短条目 |

执行器关闭了 SDK 自带的重试（`max_retries=0`），这样就只有一套重试策略，上限也一目了然。退避采用[指数退避](https://broadrouter.com/zh/glossary/exponential-backoff/)加完全随机抖动，上限 60 秒，这样一起失败的 worker 不会一起重试。尝试六次后，该条目会被写成 `"ok": false`，任务继续往下走。一个坏条目永远不会让一百万条停下来。

模型调用没有副作用，所以这里的投递语义是“至少一次”：如果进程在请求中途挂掉，重启后这个条目会被再次发送，你会为它付两次钱。这是唯一的浪费。如果任务还要写入别的系统，比如工单或邮件，就按条目 ID 让这次写入[幂等](https://broadrouter.com/zh/glossary/idempotency-key/)，并在单独一轮中遍历 `results.jsonl` 来完成。[长时间运行智能体一文](https://broadrouter.com/zh/blog/long-running-agents-timeouts-retries/)深入介绍了幂等的副作用。

## 检查点是怎么工作的？

输出文件就是检查点。每个完成的条目是一行已 flush 的内容，所以在崩溃、部署或按下 Ctrl-C 之后，下一次运行会读取这个文件，收集 `"ok": true` 的 ID，只把剩下的放进队列。之前失败的条目会在下一次运行时重试，新的结果行会被追加进去。读取结果时，每个 ID 取最后一行。

让它连续数天都稳得住，靠的是三个习惯：

1.  **稳定的 ID。** 使用数据库主键或输入内容的哈希，绝不使用输入文件一变就会移位的行号。
2.  **检查 `finish_reason`。** 在 `max_tokens` 处被截断的回复是 `"ok": true`，但毫无用处。DeepSeek V4.1 Flash、GLM 5.3 和 Qwen3.8 27B 都会先思考再回答，而[思考内容计入 max\_tokens](https://broadrouter.com/zh/guides/reasoning-tokens-empty-response/)。执行器设置了 BroadNet 文档中提供的 `reasoning_effort="low"`，并留出 1,500 个 token。
3.  **每一行都记录用量。** 把 `results.jsonl` 中的 `usage` 加总，就得到真实的 token 账单，可以和你的估算对比。

## 成本多少：按量付费还是套餐会话？

按量付费时，成本就是 token。以 10 万条评论为例：系统提示词 150 token，每条评论 150 token，低思考强度下输出 100 token。合计 3,000 万输入 token 和 1,000 万输出 token。在 [DeepSeek V4.1 Flash](https://broadrouter.com/zh/models/deepseek-v4.1-flash/) 上，费用是 30 × $0.175 + 10 × $0.52。把系统提示词放在最前面并保持逐字节一致，在命中缓存的地方，其中的 1,500 万 token 可以按[缓存输入](https://broadrouter.com/zh/blog/cached-input-tokens-explained/)价格计费，即每 1M $0.0055。你的 `usage` 行会显示实际命中了多少。

用套餐时，token 免费，成本是时间。DeepSeek V4.1 Flash 的套餐会话 “runs one request at a time”（译文：一次运行一个请求），所以每个会话设置 `IN_FLIGHT=1`。每个会话每天的吞吐量是 86,400 ÷ 每条秒数。BroadNet 给出的典型速度是 约每秒 100 个 token，但你的延迟取决于提示词长度和思考量，所以用 50 条实测一下。如果实测每条 3 秒，一个会话每天能处理 28,800 条：

| 任务 | 会话数 | 每条 3 秒时的耗时 | 套餐 |
| --- | --- | --- | --- |
| 100,000 条 | 1 | 约 3.5 天 | 一个 Orbit 周套餐，每个会话 $15 |
| 100,000 条 | 4 | 约 21 小时 | 四个 Orbit 周套餐，每个会话一个；或每个会话约 21 个 Meteor 小时，每小时 $1 |
| 1,000,000 条 | 6 | 约 6 天 | 六个 Orbit 周套餐 |

套餐以 “best effort under fair use”（译文：在合理使用前提下尽力提供）的方式交付，BroadNet 没有公布套餐密钥的每分钟请求上限；你的账户里会显示适用的限制。`RPM` 要按这些限制设置，不要靠猜。[会话规划指南](https://broadrouter.com/zh/guides/unlimited-llm-api-sessions/)解释了如何把会话分配到不同的密钥上。

## BroadNet Inference 处在什么位置

BroadNet Inference 没有 Batch API，所以当你宁愿自己掌控执行器、按正常的每 token 价格付费，或者想用 DeepSeek V4.1 Flash 套餐会话把成本固定下来时，它适合跑批量任务。对于预算有限的小任务，[Gemma 4 VL 26B](https://broadrouter.com/zh/models/gemma-4-vl-26b/) 每 1M 输入 $0.10、输出 $0.22，可以使用 $5 初始额度运行。每个请求结束后，提示词和输出都不会被保留。如果你的任务能等一天，而你需要的模型在某家有 50% 批量折扣的服务商那里，那里可能更便宜；投入之前先比较一下。套餐和限制见 [inference.broadnet.ai/plans](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=zh-blog-llm-batch-processing-without-batch-api&utm_content=body)。

相关免费工具 （英文）

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[免费工具 （英文）](https://broadrouter.com/tools/)

## 本文涉及的术语

[Token（词元）](https://broadrouter.com/zh/glossary/token/)

token（词元）是大语言模型读写文本的基本单位：由模型的分词器切分出的一个词、词的一部分、一个标点或一段字节序列。大模型 API 按 token 计数、设定限制，通常也按 token 计费。

[批处理 API（Batch API）](https://broadrouter.com/zh/glossary/batch-api/)

批处理 API 是一种异步的大模型端点：它一次接收大量请求（通常以文件形式），在设定的时间窗口内处理而不是立即处理，最后统一返回结果。OpenAI 和 Anthropic 等服务商对批处理请求的定价低于其标准 API。

[速率限制（rate limit）](https://broadrouter.com/zh/glossary/rate-limit/)

速率限制是 API 对客户端在一个时间窗口内的使用量设定的上限，例如每分钟请求数或每分钟 token 数。超出限制的请求会被拒绝，通常返回 HTTP 429 Too Many Requests，直到用量回落到限制以下。

[按量付费（pay-as-you-go）](https://broadrouter.com/zh/glossary/pay-as-you-go/)

按量付费是一种计价模式：你只为实际用量付费，按 token、请求次数或音频分钟等单位计量，没有订阅费，也没有最低消费承诺。大多数大模型 API 都这样计费，从预付余额中扣减或定期开具账单。

[并发（concurrency）](https://broadrouter.com/zh/glossary/concurrency/)

并发（concurrency）是客户端在同一时刻正在进行中的请求数。大模型 API 往往按密钥或套餐单独限制并发，与每分钟请求数分开计算，因为每个未完成的请求在响应结束前都会占用 GPU 资源。

[指数退避（exponential backoff）](https://broadrouter.com/zh/glossary/exponential-backoff/)

指数退避（exponential backoff）是一种重试策略：客户端每失败一次，就等待更长时间再重试，通常把延迟翻倍，直到达到上限。在每次等待中加入随机抖动（jitter），可以把众多客户端的重试错开，避免它们在同一时刻打到服务器上。

[工具调用（tool calling / function calling）](https://broadrouter.com/zh/glossary/tool-calling/)

工具调用（也叫函数调用，function calling）是大模型 API 的一项功能：模型返回一个结构化请求，要求执行开发者定义的某个函数，并附上 JSON 参数。应用执行该函数并把结果发回；模型自己从不执行代码。

[输入 token 与输出 token](https://broadrouter.com/zh/glossary/input-and-output-tokens/)

输入 token 是语言模型在一次请求中读取的 token，包括系统提示词、对话历史、工具定义和图片。输出 token 是模型生成回复的 token，包括思考内容。大模型 API 通常分别计价，输出一般更贵。

## 常见问题

### BroadNet Inference 有 Batch API 吗？

没有。截至 2026 年 11 月 15 日，它的 API 参考只列出 POST /v1/chat/completions、POST /v1/audio/transcriptions 和 GET /v1/models，没有批量或文件上传接口，也没有批量折扣。批量任务请在密钥的限制内以普通请求运行。

### 怎么用大模型 API 处理 10 万条提示词？

把条目放进 JSONL 文件，每条带一个 ID。运行固定数量的 worker，数量等于密钥的并发上限；按每分钟限额控制请求发起节奏；对 429 和 5xx 做有上限的退避重试；把每条结果按 ID 追加写入输出文件，这样任务可以续跑。

### 一百万个请求的批量任务要跑多久？

用条目数除以你的实际速率。每分钟 30 个请求、每个请求一条时，一个密钥每天能处理 43,200 条，一百万条约需 23 天。每个请求打包 20 条短条目，可以缩短到约 28 小时，前提是模型能处理好更长的提示词。

### 批量调用大模型，该用 asyncio.gather 还是 worker 池？

几万条以上，用固定数量的 worker 从队列中取任务。gather 加信号量适合小任务，但它会一开始就创建所有任务，让续跑和进度跟踪更难。

### 能用多个 API 密钥来加速吗？

先确认。BroadNet 的可接受使用政策禁止规避速率或并发限制，所以在把一个任务拆到多个密钥上以突破单密钥限制之前，请先询问 BroadNet。每个请求打包更多条目和使用套餐会话，是有文档说明的提高吞吐量的方式。

### 固定价格套餐适合跑批量任务吗？

对 DeepSeek V4.1 Flash 来说可以。一个会话一次运行一个请求且不计 token，所以成本是固定的，问题在于时间。先测出每条的秒数，再买足够的会话，在套餐周期内跑完。

## 继续阅读

-   [大模型 API 报 429 错误怎么办：退避、抖动与并发限制](https://broadrouter.com/zh/blog/handle-llm-api-429-rate-limits/)
-   [长时间运行的智能体：可靠的超时、重试与检查点](https://broadrouter.com/zh/blog/long-running-agents-timeouts-retries/)
-   [用大模型做阿拉伯语文本分类：情感、意图与工单分派](https://broadrouter.com/zh/blog/arabic-text-classification-llm/)
-   [如何在固定价格大模型 API 上运行并行编程智能体](https://broadrouter.com/zh/blog/run-parallel-coding-agents-flat-rate/)
-   [短期项目的大模型周套餐：Orbit、按小时还是包月](https://broadrouter.com/zh/blog/weekly-llm-plan-short-projects/)
-   [上线新功能前，怎样估算大模型 API 费用](https://broadrouter.com/zh/blog/estimate-llm-api-cost-before-launch/)
-   [BroadNet 的 GPU 硬件与推理部署方式（据 BroadNet 自述）](https://broadrouter.com/zh/blog/broadnet-gpu-fleet-and-serving/)
-   [缓存大模型 API 响应以降低成本：用 Python 实现精确匹配缓存](https://broadrouter.com/zh/blog/cache-llm-responses-cut-cost/)
-   [指南：BroadNet Inference 错误码，以及什么时候该重试](https://broadrouter.com/zh/guides/errors-and-retries/)
-   [指南：用 OpenAI Python SDK 调用 BroadNet Inference](https://broadrouter.com/zh/guides/openai-python-sdk/)
-   [指南：面向智能体的不限量 LLM API 套餐如何运作](https://broadrouter.com/zh/guides/unlimited-llm-api-sessions/)

用你的真实业务负载试一试。 新账户可获得 US$5 初始额度，用于 Gemma和转写。DeepSeek、GLM和Qwen3.8 需要先充值。

[开始使用](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=zh-blog-llm-batch-processing-without-batch-api&utm_content=page-cta) ·

**来源**

-   [BroadNet Inference API 参考：接口、按量付费限制（每分钟 30 个、同时 4 个）、按小时密钥限制、429 和 5xx 重试建议、reasoning\_effort（2026-11-15 查阅） （英文）](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=zh-blog-llm-batch-processing-without-batch-api&utm_content=sources)
-   [BroadNet Inference 套餐页面：每个会话一次一个请求、典型速度、套餐价格（2026-11-15 查阅） （英文）](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=zh-blog-llm-batch-processing-without-batch-api&utm_content=sources)
-   [BroadNet 可接受使用政策第 3、4 节：不得规避速率或并发限制；套餐在合理使用前提下尽力提供（2026-11-15 查阅） （英文）](https://www.broadnet.ai/aup)
-   [OpenAI Batch API 指南：5 折、24 小时窗口、每批 50,000 个请求或 200 MB、输出顺序可能不同、custom\_id（2026-11-15 查阅）](https://developers.openai.com/api/docs/guides/batch)
-   [Anthropic Message Batches API 文档：5 折、100,000 个请求或 256 MB、大多数批次 1 小时内完成、24 小时后过期（2026-11-15 查阅）](https://platform.claude.com/docs/en/build-with-claude/batch-processing)
