有些大模型任务不是聊天。你有 5 万张客服工单要打标签,20 万条商品描述要翻译,或者一百万条评论要打分。OpenAI 和 Anthropic 等服务商为此提供了 Batch API。很多 OpenAI 兼容 API 没有,BroadNet Inference 就是其中之一。本文介绍如何自己跑这类任务:估算需要多长时间,写一个遵守限制的执行器,并让它可以安全地停止和重启。
BroadRouter 是 BroadNet 自己的网站,所以示例中的数字使用 BroadNet 公布的限制。这个方法适用于任何 chat completions API;换成你的服务商的数字即可。
BroadNet Inference 有 Batch API 吗?
没有。截至 2026 年 11 月 15 日,API 参考列出了 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 成本计算器把两种方案都算一下。
任务要跑多久?
写代码之前先算清楚。有两个限制会卡住吞吐量,以较慢的那个为准:
- 并发上限 ÷ 延迟。 同时 4 个请求、每个请求 2 秒,你每秒能完成 2 个。
- 每分钟请求数。 每分钟 30 个,你每秒只能发起 0.5 个,无论模型有多快。
BroadNet 的按量付费密钥允许同时 4 个请求、每分钟 30 个。按我们查看时 API 参考中的数值(每分钟 30 个、同时 4 个,2026-11-15),除非每个请求超过 8 秒,否则起作用的是速率限制。下表按每分钟 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 数组。检查数组是否每个输入都有一项,且每项都带着自己的编号。阿拉伯语文本分类一文展示了这种写法。长条目没法打包:每个请求仍然要放得进模型的上下文窗口,而且列表越长质量可能越差。信任打包之前,先用 200 条测试一下。
不要未经询问就把一个任务分散到多个密钥上,以突破单密钥限制。BroadNet 的可接受使用政策禁止规避速率、并发或预算限制。如果你需要更多,请询问 BroadNet,或者使用下文介绍的套餐会话。批量任务规划器会根据你的条目数、延迟和限制来做这笔算术。
可断点续跑的执行器长什么样?
这个执行器读取 items.jsonl(每行一个 {"id", "text"} 对象),并为每个条目向 results.jsonl 追加一行结果。它只需要 OpenAI Python SDK。
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 指南在 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),这样就只有一套重试策略,上限也一目了然。退避采用指数退避加完全随机抖动,上限 60 秒,这样一起失败的 worker 不会一起重试。尝试六次后,该条目会被写成 "ok": false,任务继续往下走。一个坏条目永远不会让一百万条停下来。
模型调用没有副作用,所以这里的投递语义是“至少一次”:如果进程在请求中途挂掉,重启后这个条目会被再次发送,你会为它付两次钱。这是唯一的浪费。如果任务还要写入别的系统,比如工单或邮件,就按条目 ID 让这次写入幂等,并在单独一轮中遍历 results.jsonl 来完成。长时间运行智能体一文深入介绍了幂等的副作用。
检查点是怎么工作的?
输出文件就是检查点。每个完成的条目是一行已 flush 的内容,所以在崩溃、部署或按下 Ctrl-C 之后,下一次运行会读取这个文件,收集 "ok": true 的 ID,只把剩下的放进队列。之前失败的条目会在下一次运行时重试,新的结果行会被追加进去。读取结果时,每个 ID 取最后一行。
让它连续数天都稳得住,靠的是三个习惯:
- 稳定的 ID。 使用数据库主键或输入内容的哈希,绝不使用输入文件一变就会移位的行号。
- 检查
finish_reason。 在max_tokens处被截断的回复是"ok": true,但毫无用处。DeepSeek V4.1 Flash、GLM 5.3 和 Qwen3.8 27B 都会先思考再回答,而思考内容计入 max_tokens。执行器设置了 BroadNet 文档中提供的reasoning_effort="low",并留出 1,500 个 token。 - 每一行都记录用量。 把
results.jsonl中的usage加总,就得到真实的 token 账单,可以和你的估算对比。
成本多少:按量付费还是套餐会话?
按量付费时,成本就是 token。以 10 万条评论为例:系统提示词 150 token,每条评论 150 token,低思考强度下输出 100 token。合计 3,000 万输入 token 和 1,000 万输出 token。在 DeepSeek V4.1 Flash 上,费用是 30 × $0.175 + 10 × $0.52。把系统提示词放在最前面并保持逐字节一致,在命中缓存的地方,其中的 1,500 万 token 可以按缓存输入价格计费,即每 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 要按这些限制设置,不要靠猜。会话规划指南解释了如何把会话分配到不同的密钥上。
BroadNet Inference 处在什么位置
BroadNet Inference 没有 Batch API,所以当你宁愿自己掌控执行器、按正常的每 token 价格付费,或者想用 DeepSeek V4.1 Flash 套餐会话把成本固定下来时,它适合跑批量任务。对于预算有限的小任务,Gemma 4 VL 26B 每 1M 输入 $0.10、输出 $0.22,可以使用 $5 初始额度运行。每个请求结束后,提示词和输出都不会被保留。如果你的任务能等一天,而你需要的模型在某家有 50% 批量折扣的服务商那里,那里可能更便宜;投入之前先比较一下。套餐和限制见 inference.broadnet.ai/plans。
