如何在OpenRouter上获得最低成本的LLM推理

既然你来到这里，你就已经知道模型并不是唯一的成本变量。同一个模型在不同提供商那里的费用可能高出好几倍，而这种差价在规模化时会迅速放大。

本指南会告诉你自动获取最低价格的确切配置，以及那些一旦忽略就会推高账单的坑。

如果你已经遭遇过账单惊吓，请从"坑"这一节开始。如果你想知道 5.5% 的平台费是否值得，成本计算在底部的决策表里。如果你只想知道自己已经选定的模型哪家提供商最便宜，就在模型 slug 后面加上 :floor，然后跳到那一节。

太长不看版

• 从免费模型开始。OpenRouter 有 20 多个 token 成本为 $0 的模型。免费账户每天可获得 50 次请求。一次性充值 $10 额度，就能跃升到每天 1,000 次。
• 默认路由器本就偏向更便宜的提供商。你无需任何配置就能从中受益。
• 在任何模型 slug 后面加上 :floor，即可始终路由到该模型最便宜的提供商。
• 当你需要硬性预算上限时，使用 max_price。如果没有符合条件的提供商，请求会失败，而不是超出你的计划支出。
• 最便宜的标价有时对应的是量化端点。如果精度对你的工作负载很重要，请使用 quantizations 过滤器或 provider.ignore。

不确定哪种手段适用于你的情况？这张图告诉你从哪里开始：

什么是 :floor 成本快捷方式？

OpenRouter 上的每个模型都可以通过多个提供商获取，而它们的收费并不相同。仅以 Llama 3.3 70B 为例，根据服务方的不同，输入价格从每百万 token $0.10 到超过 $1.00 不等。

在模型 slug 后追加 :floor 即可让路由器始终选择最便宜的那个。这与在请求体中设置 provider.sort: "price" 完全一样。只需改动一个字符串：

from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="$OPENROUTER_API_KEY",
)

resp = client.chat.completions.create(
    model="meta-llama/llama-3.3-70b-instruct:floor",  # routes to the cheapest provider
    messages=[{"role": "user", "content": "Classify this ticket."}],
)

在 TypeScript 中也是如此：

import { OpenRouter } from '@openrouter/sdk';

const openRouter = new OpenRouter({ apiKey: process.env.OPENROUTER_API_KEY });

const completion = await openRouter.chat.send({
  model: 'meta-llama/llama-3.3-70b-instruct:floor',
  messages: [{ role: 'user', content: 'Classify this ticket.' }],
  stream: false,
});

与之对应的是 :nitro，它按吞吐量而非价格排序。这两者值得放在一起了解：

使用 :floor 的代价是它会禁用负载均衡，并锁定到最便宜的端点，而该端点在特定某天可能并不是最可靠的。

对于批处理任务、文档处理和离线工作负载而言，多花几秒钟无关紧要，这样的取舍是可以接受的。但对于面向用户的实时调用，就要三思了。如果最便宜的端点恰好是一个性能退化的端点，下面的注意事项部分会告诉你如何将其排除。

OpenRouter 如何默认选择便宜的提供商

在着手配置任何路由之前，先了解系统已经在为你运行什么会有所帮助。即使没有任何显式设置，OpenRouter 的默认行为也已经倾向于更便宜的提供商。

以下是具体策略：

1. 跳过在过去 30 秒内出现过严重故障的提供商。
2. 在稳定的提供商中，从成本最低的候选中进行选择，并按价格的平方倒数进行加权。
3. 将其余的作为备用。

平方反比加权正是它有用的原因。假设 Provider A 每百万 token 收费 $1，Provider B 每百万 token 收费 $2，Provider C 每百万 token 收费 $3，而 Provider B 最近出现了几次故障。你的请求会首先发往 Provider A，其概率大约是发往 Provider C 的 9 倍，因为 1 除以 3 的平方等于 1/9。如果 A 失败，下一个就是 C。B 因为故障记录而排在最后。便宜和稳定被自动平衡了。

我们构建这套加权机制，是因为我们吃尽苦头才明白朴素的统一价格路由会产生什么结果。把所有请求都发给最便宜的提供商听起来很对，直到该提供商成为负载下第一个饱和、第一个性能退化、恢复也最慢的那个。我们在 80+ 个提供商上运行这套机制，每月处理大约 100 万亿 token，而平方反比方法正是让成本节省不以可靠性为代价的关键。

有一点需要记住：在你的提供商偏好设置中设置 sort 或 order 会完全关闭这种负载均衡。下一节会告诉你什么时候你会想要覆盖它。

如何使用 max_price 设置硬性价格上限？

:floor 会路由到最便宜的提供商。max_price 则做相反的事：它会阻止请求发送到任何价格高于你所设上限的提供商。:floor 寻找下限，而 max_price 则强制执行上限。

如需预算保障，max_price 对象中的 provider 字段会限制你每百万 token 的最高支付金额：

resp = client.chat.completions.create(
    model="meta-llama/llama-3.3-70b-instruct",
    messages=[{"role": "user", "content": "Draft a release note."}],
    extra_body={
        "provider": {
            "max_price": {"prompt": 1, "completion": 2}
        }
    },
)

此路由仅指向输入 token 价格不高于 $1/M、输出 token 价格不高于 $2/M 的提供商。如果所有可用提供商都更贵，请求就会失败。这是有意为之。你宁愿看到报错，也不愿收到一笔你未曾预料到的扣费。

最实用的组合往往是 max_price 搭配 sort: "throughput"：

"provider": {
    "sort": "throughput",
    "max_price": {"prompt": 1, "completion": 2}
}

这样你就能获得可用的最快提供商，只要其输入成本不超过 $1/M、输出成本不超过 $2/M。在一个配置中同时实现速度优化的路由与硬性预算保证。

仍然足够好的最便宜模型是哪个？

提供商路由能为你已经选定的模型降低成本。选择更便宜的模型则是更大的杠杆。前沿模型与能力出色的开放权重模型之间的差距往往是每 token 10 倍到 50 倍。

像 DeepSeek V4、Llama 3.3 70B、Qwen 和 Mistral 这样的开放权重模型能很好地处理大多数生产任务：文档处理、分类、摘要、代码生成、结构化输出提取。对于大多数工作负载而言，它们是正确的选择。

同一模型在不同提供商之间的价格差距让路由的论点变得具体。以下是 Llama 3.3 70B 在四家提供商的情况：

仅输出定价这一项，同一个模型就从 $0.32 一路波动到每百万 token 超过 $1，有些端点甚至高于 $2。这正是让路由器挑选最便宜的合格提供商、而不是硬编码某一家的全部理由。

进阶做法：在满足性能下限的前提下选最便宜的模型

如果你对由哪个模型来处理请求没有硬性要求，可以给 OpenRouter 提供一组可接受的模型，让它在所有模型中找到仍能满足吞吐量阈值的最便宜端点。设置 partition: "none" 会告诉路由器按价格在所有模型间全局排序，而不是总是先尝试第一个模型：

const completion = await openRouter.chat.send({
  models: [
    'anthropic/claude-sonnet-4.5',
    'openai/gpt-5-mini',
    'google/gemini-3-flash-preview',
  ],
  messages: [{ role: 'user', content: 'Summarize this PR.' }],
  provider: {
    sort: { by: 'price', partition: 'none' },
    preferredMinThroughput: { p90: 50 },
  },
  stream: false,
});

这会将请求路由到三者中最便宜的模型与提供商组合，且该组合在 p90 下至少能提供 50 tokens 每秒。具体到编程任务，像 DeepSeek V4 和 Qwen3 Coder 这样的开放权重模型具有出色的性价比。

BYOK 如何降低成本？

如果你已经拥有某家提供商的 API 密钥，无论是通过直接合同、协商费率还是现有额度，BYOK（Bring Your Own Key，自带密钥） 都能让你使用这些密钥通过 OpenRouter 进行路由。你保留与提供商的关系和定价。OpenRouter 在此基础上增加路由、故障转移和可观测性。

费用为同一模型和提供商在 OpenRouter 上正常价格的 5%，并且按需付费模式下每月前 100 万次请求、企业版每月前 500 万次请求可免除该费用。对大多数团队而言，这意味着 BYOK 路由是免费的。

我们看到，团队往往认为 BYOK 一定更便宜，因为他们用的是自己的密钥。只有当你的直接提供商费率减去豁免额度以上那 5% 手续费后，低于 OpenRouter 的零加价目录价格时，它才比标准的按量付费更划算。每月请求量低于 100 万次时，手续费被豁免，所以如果你已有提供商的额度，几乎总是值得这么做。超过这个门槛后，先算一算，再假设它能省钱。

对于跨回退集合的 BYOK，partition: "none" 在这里也有帮助。如果你的主模型没有配置 BYOK 提供商，但某个回退模型配置了，这就能让 OpenRouter 路由到使用你密钥的那个回退模型，让更多流量走你自己的价格：

const completion = await openRouter.chat.send({
  models: ['anthropic/claude-sonnet-4.5', 'openai/gpt-5-mini'],
  messages: [{ role: 'user', content: 'Hello' }],
  provider: { sort: { by: 'price', partition: 'none' } },
  stream: false,
});

有适合业余项目的免费 LLM 模型吗？

有。OpenRouter 有 20 多个免费模型，可通过你用于其他一切的同一个端点和 API 密钥调用，token 成本为 $0。对于副业项目或周末原型，你无需花任何钱就能开始。

这份名单包括 Llama 3.3 70B、Qwen3 Coder、GPT-OSS 120B 和 NVIDIA Nemotron 3 Super 等模型。这些都是可靠的模型，对于原型开发和早期验证来说绰绰有余。

免费模型运行的请求结构与付费模型相同。你只需把模型字符串改成一个免费的 slug，就完成了：

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "meta-llama/llama-3.3-70b-instruct:free",
    "messages": [{"role": "user", "content": "Summarize this changelog in two lines."}]
  }'

你可以在 openrouter.ai/models?max_price=0 浏览完整列表，或者让 Free Models Router 自动为你挑选一个。

但有个问题：免费档的速率限制

免费账户每天可获得 50 次请求，每分钟 20 次请求。当你充值 $10 或更多额度后，免费模型的上限会提升到每天 1,000 次请求，速率仍为 20 RPM。这一笔充值永不过期。

在基于免费模型进行构建之前，你还应该知道，免费端点的上下文窗口有时比对应的付费端点更小，因此一个在付费端能跑通的长上下文任务，在免费端可能会被截断。而且失败的请求仍然会占用你的每日配额，所以一个配置错误的失败重试循环可能会在产出任何有用结果之前就耗尽你的额度。

值得了解的成本陷阱

最便宜的标价并不总是最便宜的实际成本。如果不提前规划，有几件事会推高你的账单。

最便宜的端点可能是量化端点

当输出质量意外下降时，大多数开发者会认为是模型变了，或者提供商更新了什么。一个可能的原因是量化。一些提供商以更低的价格提供量化模型权重：FP8、FP4、INT8。你的应用仍然会返回响应。只是它与全精度权重所产生的结果不同，而你的日志里没有任何信息告诉你原因。

平心而论，量化并不一定就更差。我们自己的基准分析发现，一些激进量化的端点能够与全精度的竞品相匹敌。但如果你的工作负载对精度敏感，你有两个可用的手段。

排除某个特定的提供商：

"provider": {
    "sort": "price",
    "ignore": ["provider-slug"]
}

或者用quantizations过滤器要求更高精度的服务：

"provider": {
    "sort": "price",
    "quantizations": ["fp16", "bf16"]
}

5.5% 的平台费应当计入每一次成本计算

我们不会在提供商的 token 定价上加价，但按量付费的额度购买会收取 5.5% 的平台费。充值 $100，就有 $5.50 从你的推理预算中扣除。这一点写在定价页面上，并没有隐藏，但正是这个数字让某些对比产生误导。

任何将 OpenRouter 的 token 费率与提供商直连费率进行对比、却未计入这笔费用的成本计算，都是不完整的。

取消流式传输并不总能停止计费

如果你在响应中途中止流式请求，OpenRouter 会在支持流取消的提供商处停止计费。Bedrock、Groq、Google、Mistral 以及其他几家则不支持。

如果你的应用频繁取消流式传输，无论是来自用户取消按钮、超时，还是提前短路的智能体循环，在将其作为成本控制手段依赖之前，请先确认哪些提供商支持取消。

失败的免费层请求仍会占用你的配额

如果免费模型请求因速率限制、提供商故障或超时而失败，它仍会消耗你每日 50 次或 1,000 次请求中的一次。一个误触发的重试循环可能在产生任何有用结果之前就耗尽你的配额。如果你在免费端点上构建，请添加带退避的重试逻辑。

综合起来：一条成本决策规则

以下是完整内容，以"何时使用"表格形式呈现：

贯穿始终的主线是：在 OpenRouter 上实现低成本，是一个只需做一次的配置决策。

关于这些杠杆背后的完整路由机制，请参阅 provider routing reference 和 model fallbacks。

常见问题

OpenRouter 比直接对接某家提供商更便宜吗？

就 token 定价而言，并不便宜。我们按提供商费率原样转售，不加价。它真正省钱的地方在于路由：让你能访问那些你可能并未开设账户的更便宜的提供商，自动故障转移使失败的请求不会浪费算力，以及将批处理任务路由到最便宜的可用端点，而无需你自己维护这套逻辑。真正需要考虑的成本是购买额度时 5.5% 的平台费。按每月 $500 的推理用量计算，那就是 $27.50。是否值得，取决于你原本要花多少工程时间去管理各家提供商。

OpenRouter 上最便宜的模型是什么？

免费模型的 token 成本为 $0。名单包括 Llama 3.3 70B、Qwen3 Coder、GPT-OSS 120B 和 NVIDIA Nemotron 3 Super，在没有额度的情况下限制为每天 50 次请求，充值 $10 或以上则每天 1,000 次。对于付费推理，带有 :floor 路由的开放权重模型会自动为你匹配该模型最便宜的提供商。

OpenRouter 的免费模型真的免费吗？

是的，每 token $0。限制是免费账户每天 50 次请求，充值 $10 额度后每天 1,000 次，两者均为 20 RPM。免费端点的上下文窗口有时比付费版本更小。

如何始终使用最便宜的提供商？

在你的模型 slug 后追加 :floor，或在请求体中设置 provider.sort: "price"。两者效果相同。

最便宜的 LLM API 用于编程够好吗？

对于常规编程任务，够好。像 Qwen3 Coder 和 DeepSeek V4 这样的开放权重模型能以远低于前沿模型的价格处理样板代码、重构、代码审查和文档编写。前沿模型在复杂架构和困难调试上仍有明显优势，所以把昂贵的调用留给真正需要它们的工作。

OpenRouter 会对失败的请求收费吗？

不会。你只需为成功的补全付费。失败和回退的请求不计费。