---
title: "大模型 API 429 限流处理：退避、抖动与队列 | BroadRouter"
description: "429 和 5xx 有什么区别？讲解大模型 API 的指数退避加全抖动、并发限制器和队列，附可直接用于生产环境的 Python 和 Node 代码。"
url: https://broadrouter.com/zh/blog/handle-llm-api-429-rate-limits/
lang: zh-Hans
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

本页由英文原文借助 AI 翻译。[阅读英文原文](https://broadrouter.com/blog/handle-llm-api-429-rate-limits/)（2026-11-15 更新）。

# 大模型 API 报 429 错误怎么办：退避、抖动与并发限制

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

429 表示你触发了速率、并发或支出限制。用有上限的指数退避加随机抖动来重试，服务器发送 Retry-After 时遵守它。然后从源头预防大部分 429：用信号量把同时进行的请求数限制在密钥的上限，其余排队。5xx 用同样的方式重试；其他 4xx 错误则应修正，而不是重试。

## 要点

-   对 429 和 5xx 使用有上限的指数退避重试。不要重试 400、401、403、413 或 422：应修正请求或账户。
-   全抖动（在零和指数上限之间随机等待）能避免大量客户端在同一时刻重试。
-   大多数 429 来自并发，而不是请求量。把信号量设为密钥的同时请求上限，就能从源头消除它们。
-   BroadNet 按量付费密钥每分钟允许 30 个请求、同时 4 个请求；套餐会话同一时间运行一个请求。
-   重试是新的推理。按 token 计费时每次重试都会再次计费，所以要限制尝试次数。

**本页内容**

1.  429 和 5xx 有什么区别？
2.  哪些限制会导致 429？
3.  怎么写带抖动的退避？
4.  怎样在 429 发生之前就阻止它？
5.  什么时候需要真正的队列？
6.  哪些重试错误会把 429 变成故障？
7.  BroadNet Inference 适合什么场景

429 表示你的流量超过了某个[速率限制](https://broadrouter.com/zh/glossary/rate-limit/)：每分钟请求数、同时请求数、每分钟 token 数或支出。解决它分两部分。**好好重试**：有上限的指数退避加随机抖动，并遵守 `Retry-After`。**一次少发一点**：用信号量把同时请求数限制在密钥的上限，再加一个队列。下文都附有代码。

完整的状态码参考请看[错误与重试指南](https://broadrouter.com/zh/guides/errors-and-retries/)；需要检查点和超时设置、运行数小时的智能体，请看[长时间运行的智能体：超时与重试](https://broadrouter.com/zh/blog/long-running-agents-timeouts-retries/)。

## 429 和 5xx 有什么区别？

| 状态码 | 谁的问题 | 重试？ | 怎么做 |
| --- | --- | --- | --- |
| 429 | 你的流量超过了限制 | 是 | 带抖动的退避；遵守 `Retry-After`；降低并发 |
| 500 / 502 / 503 / 504 | 服务器端 | 是 | 有上限的指数退避 |
| 连接重置、超时 | 网络或服务器 | 通常是 | 退避；对于流式输出，仅在可以接受重新计费时 |
| 400 / 422 | 请求有误 | 否 | 修正请求体 |
| 401 / 402 / 403 | 密钥、余额或策略 | 否 | 修正密钥、给账户充值、修正白名单 |
| 413 | 请求过大 | 否 | 缩小请求 |

在 BroadNet Inference 上，429 可能对应四种限制中的任何一种：速率、并发、token 速率或支出。支出限制不会在 30 秒内解除。BroadNet 的文档没有说明错误响应体的哪个字段会指出具体限制，所以请把响应体记录下来，并与密钥详情中显示的限制对照。

我们的开放数据集[大模型 API 免费额度与速率限制](https://broadrouter.com/data/llm-api-free-tiers-and-rate-limits/)比较了 14 家服务商在免费使用、起始速率限制、是否需要绑卡以及是否用免费额度数据训练等方面公布的信息，每个数值都附有来源和日期。

## 哪些限制会导致 429？

先弄清你面对的具体数字。在 BroadNet Inference 上：

| 密钥类型 | 每分钟请求数 | 同时请求数 | 其他 |
| --- | --- | --- | --- |
| 按量付费 | 30 | 4 | 共享支出预算 |
| 按小时密钥 | 120 | 1 路流 | 每分钟 300,000 token |
| 不限量套餐会话 | — | 每个会话 1 个请求 | 无 token 计量 |

对大模型来说，同时请求数最关键。流式回答会一直占用名额，直到最后一个 token 到达，所以回答越长，占用时间就越长，等于模型生成它所需的时间（BroadNet 给出的典型速度是 约每秒 100 个 token）。并行调用数一旦超过密钥的 4 个名额，多出来的调用就会收到 429，尽管你那一分钟只发了寥寥几个请求。这是[并发](https://broadrouter.com/zh/glossary/concurrency/)问题，单靠退避处理得并不好。要在上线前根据限制规划 worker 数量，可以用免费的[大模型速率限制计算器](https://broadrouter.com/tools/llm-rate-limit-calculator/)。对于由大量条目组成的固定任务，[大模型批处理任务规划器](https://broadrouter.com/tools/llm-batch-job-planner/)能把同样的限制换算成运行时间。其他服务商的计算方式不同（每分钟 token 数、每天请求数或同时请求数）；[各服务商的大模型 API 速率限制](https://broadrouter.com/zh/blog/llm-api-rate-limits-by-provider/)根据 13 家服务商自己的文档做了比较。

## 怎么写带抖动的退避？

普通的[指数退避](https://broadrouter.com/zh/glossary/exponential-backoff/)依次等待 1、2、4、8 秒。如果一百个 worker 在同一时刻被限流，它们也会在同一时刻回来。AWS 对 100 个相互竞争的客户端做的模拟发现，全抖动让调用次数减少了一半以上，并且比不加抖动的退避更快完成。最简单的版本是**全抖动**：在零和指数上限之间随机等待：

```python
import os, random, time
from openai import OpenAI, RateLimitError, APIStatusError, APIConnectionError

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"], max_retries=0)

RETRYABLE = {429, 500, 502, 503, 504}

def call_with_backoff(max_attempts=6, base=1.0, cap=60.0, **kwargs):
    for attempt in range(max_attempts):
        try:
            return client.chat.completions.create(**kwargs)
        except (RateLimitError, APIStatusError, APIConnectionError) as e:
            status = getattr(e, "status_code", None)
            if status is not None and status not in RETRYABLE:
                raise  # 400, 401, 403...: retrying will not help
            if attempt == max_attempts - 1:
                raise
            retry_after = None
            if getattr(e, "response", None) is not None:
                retry_after = e.response.headers.get("retry-after")
            wait = random.uniform(0, min(cap, base * 2 ** attempt))
            if retry_after and retry_after.isdigit():
                wait = max(wait, float(retry_after))
            time.sleep(wait)
```

`max_retries=0` 关闭了 SDK 自带的重试，避免重复重试。如果你满意 SDK 的内置行为，也可以反过来：不写自己的循环，在客户端上设置 `max_retries=4`，就像 [Python SDK 指南](https://broadrouter.com/zh/guides/openai-python-sdk/)里那样。官方 Python 和 Node SDK 默认对连接错误、408、409、429 和 5xx 重试两次。

`Retry-After` 是一个标准响应头（RFC 9110），值可以是秒数或日期。BroadNet 的文档并未承诺一定会发送它，所以代码把它当作可选项处理。

## 怎样在 429 发生之前就阻止它？

把同时进行的请求数限制在密钥的上限。在 Python 中，`asyncio.Semaphore` 只需一个对象加一个 `async with` 块就能搞定。代码以 4 为例；请把它设为你的密钥的同时请求上限（BroadNet 按量付费密钥为 4）：

```python
import asyncio, os
from openai import AsyncOpenAI

client = AsyncOpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"], max_retries=4)
slots = asyncio.Semaphore(4)  # match the key's in-flight limit

async def ask(prompt):
    async with slots:
        r = await client.chat.completions.create(
            model="broadnet/gemma-4-26b-a4b",
            messages=[{"role": "user", "content": prompt}],
        )
        return r.choices[0].message.content

async def main(prompts):
    return await asyncio.gather(*(ask(p) for p in prompts))

results = asyncio.run(main(["Summarise A", "Summarise B", "Summarise C"]))
```

`gather` 会启动所有任务，但同时运行的数量不会超过信号量允许的数量，其余的在信号量的队列中等待。在 Node 中，`p-limit` 包可以做同样的事，同样以 4 为示例值：

```javascript
// ES module (top-level await). npm install openai p-limit
import OpenAI from "openai";
import pLimit from "p-limit";

const client = new OpenAI({ baseURL: "https://inference.broadnet.ai/v1", apiKey: process.env.BROADNET_API_KEY, maxRetries: 4 });
const limit = pLimit(4); // match the key's in-flight limit

async function ask(prompt) {
  const r = await client.chat.completions.create({
    model: "broadnet/gemma-4-26b-a4b",
    messages: [{ role: "user", content: prompt }],
  });
  return r.choices[0].message.content;
}

const prompts = ["Summarise A", "Summarise B", "Summarise C"];
const results = await Promise.all(prompts.map((p) => limit(() => ask(p))));
```

如果还要满足每分钟上限，再加一个令牌桶，每 60 / rpm 秒放出一个许可，其中 rpm 是你的密钥每分钟的请求数上限（BroadNet 按量付费密钥为 30）。

## 什么时候需要真正的队列？

信号量只存在于一个进程里。一旦多个 worker 或服务器共用一个密钥，限制是共享的，而每个进程只能看到自己的流量。这时：

1.  把任务放进共享队列（Redis、SQS、数据库表）。
2.  运行固定数量的消费者，数量等于密钥的同时请求上限。
3.  给每个任务一个 ID，并按 ID 存储结果，这样重试的任务不会执行两次。
4.  交互流量和批处理流量走不同的密钥或不同的队列，这样批处理积压永远不会挡住正在等待回复的用户。

对于数千个条目、又没有 Batch API 的批量任务，请看[可续跑的批处理执行器](https://broadrouter.com/zh/blog/llm-batch-processing-without-batch-api/)。

## 哪些重试错误会把 429 变成故障？

-   \*\*无上限的重试。\*\*在长时间故障期间，没有上限的重试循环会成倍放大你的负载，在按 token 计费时还会放大你的账单。
-   \*\*盲目重试只完成了一半的流。\*\*如果流已经返回了一些 token，重试就是一次全新的推理，用户可能会看到重复的文字。如何检测不完整的流，请看[流式输出一文](https://broadrouter.com/zh/blog/llm-streaming-sse-explained/)。
-   \*\*重试账户错误。\*\*按量付费额度用完时的 401，或余额不足时的 402，不会自己好起来。

记录每一次重试的状态码、等待时间和响应头 `X-Request-ID`，BroadNet 的文档要求你保留它以便联系支持。重试率上升，是你需要更多容量的最早信号；[用量日志](https://broadrouter.com/zh/blog/llm-api-usage-logging/)介绍了如何记录它。

## BroadNet Inference 适合什么场景

BroadNet 的限制是公开的，而且小到足以据此做设计：按量付费密钥同时 4 个请求。这适合应用和智能体，但对于想在一个密钥上同时发起数百个调用的批量任务来说太紧了。对于智能体，[不限量套餐](https://broadrouter.com/zh/guides/unlimited-llm-api-sessions/)没有 token 计量，每个会话同一时间运行一个请求；需要并行时就增加会话，详见[并行运行编程智能体](https://broadrouter.com/zh/blog/run-parallel-coding-agents-flat-rate/)。当前限制请看 [API 参考](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=zh-blog-handle-llm-api-429-rate-limits&utm_content=body#limits)。

相关免费工具（英文）

-   [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/)

## 本文涉及的术语

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

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

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

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

[按量付费（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 资源。

[AI 智能体（AI agent）](https://broadrouter.com/zh/glossary/agent/)

AI 智能体是由语言模型自主决定步骤、朝目标推进的系统：它决定调用哪些工具、读取结果，然后重复，直到给出最终回答或触及上限。在固定位置调用模型的固定脚本，通常称为工作流（workflow）。

[大模型包月套餐（flat-rate LLM plan）](https://broadrouter.com/zh/glossary/flat-rate-llm-plan/)

大模型包月套餐（固定价格套餐）是按一个周期（如一个月）收取固定费用、提供大模型 API 使用权的计价方式，不按 token 计费。这类套餐通常会限制别的东西，如并发、速度、模型或使用时间窗口，所以限制条件和价格同样重要。

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

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

[每秒 token 数（TPS，tokens per second）](https://broadrouter.com/zh/glossary/tokens-per-second/)

每秒 token 数（TPS）是语言模型生成输出 token 的速率，通常针对单个请求、在首个 token 到达之后测量。它决定了回复开始后流得有多快。把所有并发请求加起来就是系统吞吐量；首个 token 之前的等待时间则单独测量。

## 常见问题

### 大模型 API 返回 HTTP 429 是什么意思？

Too Many Requests（请求过多）。你超过了每分钟请求数、同时请求数、每分钟 token 数或支出的某项限制。该请求没有被处理，所以等待一段时间后重新发送是安全的。

### 遇到 429，应该等多久再重试？

如果服务器发送了 Retry-After，就按它来。否则从 1 秒左右开始，每次翻倍，上限设在 30 到 60 秒左右，在零和该上限之间随机选择等待时间。尝试四到六次后停止。

### 大模型 API 的 500 和 503 错误要重试吗？

要，用同样有上限的退避。它们是服务器端的问题。400、401、403 或 422 每次都会以同样的方式失败，所以应该修正它们。

### OpenAI SDK 会自动重试 429 吗？

会。官方 Python 和 Node SDK 默认对连接错误、408、409、429 和 5xx 重试两次，使用较短的指数退避。批处理任务可以调大 max\_retries，并加上你自己的并发限制。

### 每分钟请求数没超，为什么还是报 429？

通常是并发限制。较长的流式响应会占用好几秒甚至更久，所以几个并行调用就可能撞上同时请求上限，而每分钟请求数看起来并不高。

## 继续阅读

-   [长时间运行的智能体：可靠的超时、重试与检查点](https://broadrouter.com/zh/blog/long-running-agents-timeouts-retries/)
-   [大模型流式输出详解：SSE 分块、delta、用量与取消](https://broadrouter.com/zh/blog/llm-streaming-sse-explained/)
-   [如何在固定价格大模型 API 上运行并行编程智能体](https://broadrouter.com/zh/blog/run-parallel-coding-agents-flat-rate/)
-   [大模型 API 用量日志：按用户和功能算成本，脱敏 PII](https://broadrouter.com/zh/blog/llm-api-usage-logging/)
-   [没有 Batch API 也能批量调用大模型：可断点续跑的执行器](https://broadrouter.com/zh/blog/llm-batch-processing-without-batch-api/)
-   [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-handle-llm-api-429-rate-limits&utm_content=page-cta) ·

**来源**

-   [BroadNet Inference API 参考：错误与限制（2026-11-14 获取）（英文）](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=zh-blog-handle-llm-api-429-rate-limits&utm_content=sources#errors)
-   [AWS 架构博客：Exponential Backoff and Jitter（2026-11-14 获取）](https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/)
-   [RFC 6585：状态码 429 Too Many Requests（2026-11-14 获取）](https://www.rfc-editor.org/rfc/rfc6585#section-4)
-   [RFC 9110：Retry-After 头（2026-11-14 获取）](https://www.rfc-editor.org/rfc/rfc9110#field.retry-after)
-   [openai-python README：自动重试（2026-11-14 获取）](https://github.com/openai/openai-python)
-   [openai-node README：重试（2026-11-14 获取）](https://github.com/openai/openai-node)
