API on KnightLi的博客

大模型 API 为什么按 Token 收费：一文讲清输入、输出和上下文成本

Sat, 25 Apr 2026 08:44:32 +0800

大模型 API 的计费方式里，最容易让人困惑的一点，就是为什么几乎所有平台最后都会落到 token 这个单位上：大模型为什么按 token 收费，而且不同 token 还会有不同价格。

很多人刚接触模型 API 时，最容易困惑的不是模型能力，而是账单。明明只问了几个问题，为什么费用会涨得这么快？为什么输入便宜、输出更贵？为什么上下文一长，成本就开始明显失控？

如果把这件事讲简单一点，可以先记住一句话：模型收费，买的不是“一次回答”，而是整段推理过程中消耗的计算与带宽资源。

1. 什么是 token

在大模型计费里，token 不是“字数”也不是“单词数”，而是模型处理文本时使用的切分单位。

它可能是：

一个汉字
一个英文单词的一部分
一个标点符号
一小段常见词组合

所以 API 平台通常不会按“每句话”或“每次请求”收费，而是按模型实际读入和生成的 token 数量收费。
这比按请求次数计费更合理，因为同样是一次请求，可能只输入 20 个字，也可能塞进去 20 万 token 的上下文，两者消耗完全不是一个量级。

2. 为什么输入和输出要分开定价

现在大多数模型 API，都会把价格拆成两部分：

输入 token 价格
输出 token 价格

而且常见情况是：输出 token 比输入 token 更贵。

原因并不难理解。

模型处理输入时，本质上是在“读”和“编码”已有内容；但生成输出时，它需要一步一步预测下一个 token，再继续预测下一个 token。这个过程不只是读取，而是持续进行推理和采样，所以通常更耗算力。

你可以把它粗略理解成：

输入：像把材料递给模型
输出：像让模型现场写答案

“现场写”的计算成本，通常比“把材料读一遍”更高，所以输出价格更贵是很常见的设计。

3. 为什么上下文越长，费用越容易失控

很多人以为自己只是在“多贴一点背景资料”，但从模型账单的角度看，这件事的影响往往比想象中大。

原因在于：模型每次调用时，通常都要重新处理当前请求里带进去的整段上下文。

也就是说，如果你当前请求里包含：

系统提示词
历史对话
工具返回结果
长文档片段
代码文件内容

这些内容都会一起进入输入 token 计费。

所以真正让账单变大的，往往不是最后那一句提问，而是它前面拖着的一大串上下文。
当对话轮数增加、工具调用变多、历史消息不断回灌时，token 成本就会被一轮轮放大。

4. 工具调用为什么特别容易涨 token

在 Agent、代码助手、工作流自动化这类场景里，token 消耗通常比普通聊天高得多。

问题不只是“模型回答了一段话”，而是整个流程里会不断出现这些内容：

读文件
看日志
调接口
返回 JSON
执行工具结果再回填给模型

每一次工具调用的结果，只要被重新塞回下一轮上下文，就会继续变成新的输入 token。

这就是为什么很多开发者会发现：
不是模型本身单价特别离谱，而是工作流把 token 账单一层层叠上去了。

例如一个编码 Agent 连续做下面这些事：

读取项目结构
打开几个源码文件
跑一次测试
把报错日志喂回模型
再读取更多相关文件

每一步都可能让后续请求背着更长的上下文继续跑。这样即使单价不变，总账单也会很快增长。

5. 为什么同样是模型，价格会差很多

不同模型的 token 价格差异，背后通常不只是“厂商想卖贵一点”，而是和几个因素直接相关：

模型规模
推理效率
上下文长度
部署成本
目标市场

模型越大、激活参数越多、推理链路越复杂，单次生成一个 token 的成本通常就越高。
如果模型还支持超长上下文、复杂推理、工具调用优化，那它的基础设施压力也会进一步增加。

所以定价本质上是在覆盖几类成本：

GPU / 加速卡资源
显存占用
推理延迟
网络与服务稳定性
峰值并发能力

便宜模型不一定差，贵模型也不一定适合所有场景。很多时候价格差，反映的是“这类能力大概值多少基础设施成本”。

6. 为什么缓存输入会更便宜

不少模型平台现在会提供：

cached input
prompt caching
prefix caching

这类能力的共同思路是：如果一大段输入已经算过，不要每次都从头按原价重算。

比如一个固定 system prompt、固定工具说明、固定长文档前缀，如果每轮都完全重复发送，平台就有机会把其中一部分计算缓存下来。这样同样是输入 token，缓存命中的部分就可以按更低价格计费。

这也解释了为什么很多 API 价格页会出现三档甚至更多价格：

普通输入
缓存输入
输出

它们反映的不是文字内容不同，而是底层计算是否可以复用。

7. “便宜 token”为什么不等于“总成本更低”

很多人看到某个模型“每百万 token 超便宜”，第一反应是总成本一定更低。实际上不一定。

因为总账单大致等于：

token 单价 × 实际消耗量

而实际消耗量又会被很多因素放大：

提示词写得太长
历史消息不清理
工具结果回填过多
输出太啰嗦
一个任务反复重试

所以真正决定账单的，通常不是单价一个变量，而是：

模型单价
每轮输入长度
每轮输出长度
调用次数
工作流设计

这也是为什么“低单价模型”在某些 Agent 任务里，最后总费用仍然可能不低。因为它可能需要更多轮交互、更多补充上下文、更多失败重试。

8. 开发者该怎么估算 token 成本

如果你想在项目里更稳地控制预算，可以先用一个很朴素的估算方式：

统计平均每次请求的输入 token
统计平均每次请求的输出 token
估算一个任务会调用多少轮
再乘上对应模型单价

举个思路上的例子：

每轮输入 8k tokens
每轮输出 1k tokens
一个任务跑 10 轮

那它真正消耗的就不是“一次问答”，而是：

输入约 80k tokens
输出约 10k tokens

如果中途还有日志、工具结果、文件内容不断追加，总量还会继续上升。

所以做预算时，最好不要只看单轮，而要看一个完整任务闭环到底会吃掉多少 token。

9. 怎么实际控制账单

如果你已经在用 API 或 Agent，下面这些做法通常最有效：

缩短 system prompt，避免重复废话
定期裁剪历史消息
工具返回结果只保留必要字段
长文档先检索，再喂局部片段
控制输出长度，避免模型无上限展开
对高价值任务用贵模型，低价值任务用便宜模型

很多时候，省钱最有效的方式不是一味换更便宜的模型，而是先把工作流里无意义的 token 消耗砍掉。

10. 这件事真正该怎么理解

大模型 token 定价，说到底是在给“模型读了多少、想了多少、写了多少”计费。

它不是传统软件那种按账号、按次数、按包月就能完全描述的资源模型，因为模型调用本身就是一个动态计算过程。你塞进去的上下文、拉起的工具、要求的输出长度，都会直接影响成本。

所以理解 token 定价，最重要的不是背价格表，而是先建立一个直觉：

长上下文会涨输入成本
长输出会涨生成成本
工具链会放大总 token
缓存和工作流设计会明显影响账单

只要把这几个点想清楚，大多数模型 API 的价格结构其实都不难理解。

DeepSeek-V4 Preview 发布：1M 上下文、双模型与 API 切换提醒

Fri, 24 Apr 2026 22:39:46 +0800

DeepSeek 在 2026-04-24 发布了 DeepSeek V4 Preview Release。从官方新闻页来看，这次更新的重点非常集中：1M context、V4-Pro 与 V4-Flash 双模型、对 Agent 场景的专门优化，以及 API 侧的模型切换。

如果只看一句话，这次发布的核心信号是：DeepSeek 不只是继续做更强的模型，而是在把超长上下文和 Agent 能力一起往“可直接上线使用”的方向推进。

1. 这次一共发布了什么

官方页面里，DeepSeek-V4 Preview 主要包含两条产品线：

DeepSeek-V4-Pro
DeepSeek-V4-Flash

对应的官方描述也很直接：

DeepSeek-V4-Pro：1.6T total / 49B active params
DeepSeek-V4-Flash：284B total / 13B active params

从命名就能看出来，这次不是单模型升级，而是把高性能版本和更高性价比版本同时推了出来。

其中 V4-Pro 更强调上限，官方说它的表现已经可以和全球顶级闭源模型竞争；V4-Flash 则更强调速度、效率和成本，更适合对响应速度和 API 成本更敏感的场景。

2. `1M context` 是这次最突出的卖点

官方页面最醒目的表述之一，就是：“Welcome to the era of cost-effective 1M context length.”

DeepSeek 这次不只是说“支持长上下文”，而是明确把 1M context 当成这代模型的默认能力来讲。页面里也写得很清楚：

1M context 已经成为官方 DeepSeek 服务的默认标准
V4-Pro 和 V4-Flash 都支持 1M context

这件事的意义不只是“能塞更多 token”。它更直接影响下面这些任务：

长代码仓库理解
长文档问答和资料整合
多轮 Agent 工作流
跨多文件、多工具、多阶段的复杂任务

如果上下文窗口足够大，模型就更不容易因为中途丢上下文而反复回读材料，这对 Agent 编码和复杂知识工作会特别重要。

3. `V4-Pro` 主要在强调什么

从官方页的措辞看，DeepSeek-V4-Pro 重点强调三件事：

Agentic Coding 能力
世界知识
推理能力

页面里提到，V4-Pro 在 Agentic Coding benchmark 上达到开源 SOTA；在世界知识方面领先当前开源模型，仅落后于 Gemini-3.1-Pro；在数学、STEM 和编码能力上超过当前开源模型，并且可以和顶级闭源模型竞争。

换句话说，V4-Pro 的定位并不是单纯回答问题，而是更偏向高难度推理、复杂编码和长任务执行。

4. `V4-Flash` 并不是简单的缩水版

另一个值得注意的点是，官方没有把 V4-Flash 包装成“低配模型”，而是强调它在很多实际任务里已经足够强。

按照新闻页给出的说法，V4-Flash：

推理能力已经很接近 V4-Pro
在简单 Agent 任务上与 V4-Pro 表现相当
参数规模更小，响应更快，API 定价更便宜

这意味着 DeepSeek 这次给出的并不是“一个旗舰、一个入门”的非常割裂的组合，而更像是：

V4-Pro：追求更高性能和更强上限
V4-Flash：追求更低延迟和更好成本效率

对于开发者来说，这样的组合会更实用，因为很多线上任务真正需要的不是“理论最强”，而是“够强、够快、够省”。

5. 官方特别强调了 Agent 优化

这次发布页里还有一个很明确的方向：DeepSeek 在主动把 V4 往 Agent 场景上推。

官方页面提到，DeepSeek-V4 已经和一些主流 AI Agent 深度集成，包括：

Claude Code
OpenClaw
OpenCode

同时 DeepSeek 也提到，V4 已经在内部 agentic coding 场景中使用。

这说明它想覆盖的，不再只是聊天或普通补全，而是更长链路的工作方式：读代码、理解结构、调用工具、生成结果，再把整条流程串起来。

如果你最近正好在关注 coding agent，这个信号值得留意。因为它意味着模型厂商已经不再只拼 benchmark，而是在拼“能不能真正接进工作流”。

6. 底层结构创新在为长上下文服务

在技术描述上，官方页把这次的结构创新总结为：

token-wise compression
DSA (DeepSeek Sparse Attention)

页面给出的方向非常明确：目标是把长上下文做得更便宜、更高效，尽量降低计算和显存成本。

虽然新闻页没有展开完整技术细节，但这至少说明 DeepSeek 这次不是单纯靠“更大算力硬堆更长窗口”，而是在结构层面针对长上下文效率做了专门优化。

对实际使用者来说，这通常比单纯“窗口数字变大”更重要，因为真正决定可用性的，不只是能不能开到 1M，还包括：

速度是否还能接受
成本是否还能接受
长上下文任务是否真的稳定

7. API 已经可用，但要注意模型切换

官方页面明确写到，这次 API 当天就已经可用。

接入方式也比较简单：

base_url 保持不变
把模型名切换为 deepseek-v4-pro 或 deepseek-v4-flash

同时页面说明，这两个模型都支持：

1M context
Thinking / Non-Thinking 双模式
OpenAI ChatCompletions
Anthropic APIs

这意味着如果你原本已经接了 DeepSeek API，升级门槛并不高，主要是模型名切换和能力验证。

8. 旧模型的退役时间也写得很明确

对开发者来说，这次新闻页里最不能忽略的信息之一，其实是旧模型退役提醒。

官方写明：

deepseek-chat
deepseek-reasoner

会在 2026 年 7 月 24 日 15:59（UTC） 后完全退役并不可访问。

页面还说明，当前这两个模型实际上已经路由到 deepseek-v4-flash 的非思考 / 思考模式。

这意味着如果你的项目里还直接写着 deepseek-chat 或 deepseek-reasoner，现在就应该开始安排迁移，而不要拖到正式下线前再处理。

9. 这次发布值得怎么理解

如果把这次更新浓缩成几个重点，大概可以这样看：

DeepSeek 开始把 1M context 从“高配能力”变成默认标准
双模型路线更清晰：一个冲性能上限，一个冲速度和性价比
Agent 能力已经被放到很核心的位置
API 升级路径相对直接，但旧模型退役时间需要尽快关注

对普通使用者来说，最直观的变化可能是：长文档、长代码、长流程任务会更容易放进一次上下文里。
对开发者来说，更重要的是：如果你已经在做 Agent、代码助手、资料整理、复杂工作流，这一代模型显然就是朝这些场景设计的。

DeepSeek 这次发布，不只是一次常规模型更新，更像是在明确它下一阶段的产品方向：超长上下文 + Agent 优化 + 更实际的 API 可用性。

Codex 额度用量统计

Sun, 12 Apr 2026 00:01:33 +0800

如果你想查看 Codex 当前账号的额度剩余情况，可以直接写一个小脚本去请求 ChatGPT 的 /backend-api/wham/usage 接口。

这类脚本的思路很简单：

从 auth.json 里读取 tokens.access_token 和 tokens.account_id
请求 https://chatgpt.com/backend-api/wham/usage
在请求头里带上 Authorization: Bearer ... 和 ChatGPT-Account-Id
解析返回结果里的五小时窗口和周窗口额度

适合做什么

这个方法适合你在本地快速确认：

五小时额度还剩多少
周额度还剩多少
额度会在什么时候重置

如果你有多个账号，也可以让脚本批量读取 account/*.auth.json，统一输出一张摘要表。 auth.json文件可以从 ~/.codex/ 目录下找到, 对应你当前登录的chatgpt账户。

最关键的输入

脚本通常只依赖两项凭证：

access_token
account_id

它们一般都可以从本地 auth.json 中拿到。只要这两个值有效，请求头就能按下面的形式组织：

headers = {
    "Authorization": f"Bearer {auth_token}",
    "Accept": "application/json",
    "ChatGPT-Account-Id": auth_account_id,
    "Origin": "https://chatgpt.com",
    "Referer": "https://chatgpt.com/",
    "User-Agent": "Mozilla/5.0",
}

返回结果怎么看

接口返回后，重点看的是两类窗口：

five_hour
weekly

脚本可以把它们统一整理成下面几项：

剩余额度百分比
重置时间
对应的时间窗口长度

如果接口字段名有差异，也可以顺手兼容 primary_window、secondary_window、five_hour_limit、weekly_limit 这些变体。

常见问题

如果脚本返回 401，通常说明 access_token 已过期或无效。

如果返回 403，通常说明当前账号没有权限访问这个接口，或者账号状态异常。

如果你看到同一个响应里字段命名不一致，也不用太意外。实际处理时最好把不同命名方式统一映射后再输出。

参考链接

codex-auth-manager：https://github.com/RioArisk/codex-auth-manager

代码

import argparse
import base64
import json
import os
import sys
from datetime import datetime, timedelta, timezone
from pathlib import Path
from typing import Any

import requests


UTC = timezone.utc
CST = timezone(timedelta(hours=8), name="CST")
JSONDict = dict[str, Any]


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Query ChatGPT Codex usage from /backend-api/wham/usage."
    )
    parser.add_argument(
        "account_name",
        nargs="?",
        help="Account name used to load account/<account_name>.auth.json. If omitted, load all *.auth.json files in account/.",
    )
    parser.add_argument(
        "--account-dir",
        default="account",
        help="Directory containing <account_name>.auth.json files.",
    )
    parser.add_argument(
        "--chatgpt-url",
        default="https://chatgpt.com/backend-api/wham/usage",
        help="ChatGPT usage endpoint.",
    )
    parser.add_argument(
        "--raw-json",
        action="store_true",
        help="Print the full JSON response body.",
    )
    parser.add_argument(
        "--raw-headers",
        action="store_true",
        help="Print response headers.",
    )
    return parser.parse_args()


def print_json(data: Any) -> None:
    print(json.dumps(data, indent=2, ensure_ascii=False))


def load_auth_json(path_str: str | Path | None) -> JSONDict | None:
    if not path_str:
        return None
    path = Path(path_str).expanduser()
    if not path.is_file():
        return None
    try:
        return json.loads(path.read_text(encoding="utf-8"))
    except (OSError, json.JSONDecodeError):
        return None


def get_nested_string(data: JSONDict | None, *keys: str) -> str | None:
    current: Any = data
    for key in keys:
        if not isinstance(current, dict):
            return None
        current = current.get(key)
    return current if isinstance(current, str) and current else None


def format_dt(dt: datetime | None) -> str:
    if dt is None:
        return "-"
    return dt.astimezone(CST).strftime("%Y-%m-%d %H:%M:%S %Z")


def format_cst(dt: datetime | None) -> str:
    return format_dt(dt)


def epoch_ms_to_dt(value: Any) -> datetime | None:
    if value is None:
        return None
    try:
        raw = int(value)
    except (TypeError, ValueError):
        return None
    # Newer responses sometimes use epoch seconds, older ones use epoch milliseconds.
    timestamp = raw / 1000 if raw > 10**11 else raw
    return datetime.fromtimestamp(timestamp, tz=UTC)


def first_dict(data: Any, *keys: str) -> JSONDict | None:
    for key in keys:
        value = data.get(key) if isinstance(data, dict) else None
        if isinstance(value, dict):
            return value
    return None


def decode_jwt_exp(token: str) -> datetime | None:
    parts = token.split(".")
    if len(parts) != 3:
        return None
    try:
        payload = parts[1]
        payload += "=" * (-len(payload) % 4)
        data = json.loads(base64.urlsafe_b64decode(payload.encode("ascii")))
        exp = data.get("exp")
        if exp is None:
            return None
        return datetime.fromtimestamp(int(exp), tz=UTC)
    except (ValueError, TypeError, json.JSONDecodeError):
        return None


def get_percent_left(value: JSONDict) -> float | int | None:
    percent_left = value.get("percent_left")
    if percent_left is None:
        percent_left = value.get("remaining_percent")
    if percent_left is not None:
        return percent_left

    used_percent = value.get("used_percent")
    try:
        if used_percent is not None:
            return max(0, 100 - float(used_percent))
    except (TypeError, ValueError):
        return None
    return None


def resolve_limit_window(value: JSONDict) -> JSONDict:
    if (
        "reset_at" not in value
        and "reset_time_ms" not in value
        and isinstance(value.get("primary_window"), dict)
    ):
        return value["primary_window"]
    return value


def parse_limit_entry(name: str, value: Any) -> JSONDict | None:
    if not isinstance(value, dict):
        return None

    value = resolve_limit_window(value)

    percent_left = get_percent_left(value)
    reset_time_ms = value.get("reset_time_ms")
    if reset_time_ms is None:
        reset_time_ms = value.get("reset_at")

    window_seconds = value.get("limit_window_seconds")

    return {
        "name": name,
        "percent_left": percent_left,
        "reset_time_ms": reset_time_ms,
        "reset_at": epoch_ms_to_dt(reset_time_ms),
        "limit_window_seconds": window_seconds,
    }


def infer_limit_name(window_seconds: Any) -> str | None:
    if not isinstance(window_seconds, (int, float)):
        return None
    if window_seconds <= 6 * 3600:
        return "five_hour"
    if window_seconds >= 6 * 24 * 3600:
        return "weekly"
    return None


def relabel_rate_limits(primary: JSONDict | None, secondary: JSONDict | None) -> tuple[JSONDict | None, JSONDict | None]:
    for entry in (primary, secondary):
        if not entry:
            continue
        inferred_name = infer_limit_name(entry.get("limit_window_seconds"))
        if inferred_name:
            entry["name"] = inferred_name

    if primary and secondary and primary.get("name") == secondary.get("name"):
        if primary.get("name") == "weekly":
            primary["name"] = "five_hour"
        else:
            secondary["name"] = "weekly"

    if primary and primary.get("name") == "weekly" and secondary is None:
        return None, primary

    if secondary and secondary.get("name") == "five_hour" and primary is None:
        return secondary, None

    return primary, secondary


def parse_rate_limits(data: JSONDict) -> tuple[JSONDict | None, JSONDict | None]:
    primary = None
    secondary = None

    for primary_key in ("five_hour", "five_hour_limit", "five_hour_rate_limit", "primary"):
        if primary_key in data:
            primary = parse_limit_entry("five_hour", data.get(primary_key))
            if primary:
                break

    for secondary_key in ("weekly", "weekly_limit", "weekly_rate_limit", "secondary"):
        if secondary_key in data:
            secondary = parse_limit_entry("weekly", data.get(secondary_key))
            if secondary:
                break

    if primary is None:
        primary = parse_limit_entry("five_hour", data.get("primary_window"))
    if secondary is None:
        secondary = parse_limit_entry("weekly", data.get("secondary_window"))

    return relabel_rate_limits(primary, secondary)


def format_percent(value: Any) -> str:
    return f"{value:g}" if isinstance(value, (int, float)) else str(value if value is not None else "-")


def percent_sort_value(value: Any, descending: bool) -> tuple[int, float]:
    if isinstance(value, (int, float)):
        numeric_value = float(value)
        return (0, -numeric_value if descending else numeric_value)
    return (1, 0.0)


def get_auth_paths(account_dir: str, account_name: str | None) -> list[Path]:
    base_dir = Path(account_dir)
    if account_name:
        return [base_dir / f"{account_name}.auth.json"]
    return sorted(base_dir.glob("*.auth.json"))


def get_account_name_from_path(path: Path) -> str:
    suffix = ".auth.json"
    return path.name[: -len(suffix)] if path.name.endswith(suffix) else path.stem


def build_summary_row(account_name: str, five_hour: JSONDict | None, weekly: JSONDict | None) -> JSONDict:
    return {
        "account": account_name,
        "five_hour_percent": five_hour["percent_left"] if five_hour else None,
        "weekly_percent": weekly["percent_left"] if weekly else None,
        "weekly_reset_at": weekly["reset_at"] if weekly else None,
    }


def print_summary_rows(rows: list[JSONDict]) -> None:
    if not rows:
        return

    sorted_rows = sorted(
        rows,
        key=lambda row: (
            percent_sort_value(row.get("five_hour_percent"), descending=True),
            percent_sort_value(row.get("weekly_percent"), descending=True),
            format_cst(row.get("weekly_reset_at")),
            row["account"],
        ),
    )

    display_rows = []
    for row in sorted_rows:
        display_rows.append(
            {
                "account": str(row["account"]),
                "five_hour": format_percent(row.get("five_hour_percent")),
                "weekly": format_percent(row.get("weekly_percent")),
                "weekly_reset": format_cst(row.get("weekly_reset_at")),
            }
        )

    headers = {
        "account": "account",
        "five_hour": "five_hour%",
        "weekly": "weekly%",
        "weekly_reset": "weekly_reset",
    }
    widths = {
        key: max(len(headers[key]), max(len(item[key]) for item in display_rows))
        for key in headers
    }

    print(
        f"{headers['account']:<{widths['account']}}  "
        f"{headers['five_hour']:>{widths['five_hour']}}  "
        f"{headers['weekly']:>{widths['weekly']}}  "
        f"{headers['weekly_reset']:<{widths['weekly_reset']}}"
    )
    for item in display_rows:
        print(
            f"{item['account']:<{widths['account']}}  "
            f"{item['five_hour']:>{widths['five_hour']}}  "
            f"{item['weekly']:>{widths['weekly']}}  "
            f"{item['weekly_reset']:<{widths['weekly_reset']}}"
        )


def validate_token_inputs(
    token: str,
    account_id: str,
    auth_token: str | None,
    auth_account_id: str | None,
) -> int | None:
    if token.startswith("sess-"):
        print("status: invalid_token_type", file=sys.stderr)
        print(
            "message: --chatgpt-token looks like a session token (sess-...). Use the JWT access_token instead.",
            file=sys.stderr,
        )
        if auth_token:
            print(
                "hint: Found tokens.access_token in auth.json; omit --chatgpt-token or pass that value instead.",
                file=sys.stderr,
            )
        return 1

    token_exp = decode_jwt_exp(token)
    if token_exp is not None and token_exp <= datetime.now(UTC):
        print("status: expired", file=sys.stderr)
        print(f"message: access_token expired at {format_dt(token_exp)}", file=sys.stderr)
        if auth_token and auth_token != token:
            auth_token_exp = decode_jwt_exp(auth_token)
            hint = format_dt(auth_token_exp) if auth_token_exp else "unknown time"
            print(f"hint: auth.json contains a different access_token expiring at {hint}", file=sys.stderr)
        return 1

    if auth_account_id and account_id != auth_account_id:
        print("warning: supplied --account-id does not match auth.json tokens.account_id", file=sys.stderr)

    return None


def handle_error_response(response: requests.Response, data: Any, raw_json: bool) -> int | None:
    if response.status_code == 401:
        print("status: expired", file=sys.stderr)
        print("message: Token 已过期或无效", file=sys.stderr)
        if raw_json:
            print_json(data)
        return 3

    if response.status_code == 403:
        print("status: forbidden", file=sys.stderr)
        print("message: 账号已被封禁或无权访问", file=sys.stderr)
        if raw_json:
            print_json(data)
        return 3

    if response.status_code >= 400:
        print(f"HTTP {response.status_code}", file=sys.stderr)
        print_json(data)
        return 3

    return None


def fetch_chatgpt_usage(auth_path: Path, args: argparse.Namespace) -> tuple[int, JSONDict | None]:
    auth_data = load_auth_json(auth_path)
    account_name = get_account_name_from_path(auth_path)
    auth_token = get_nested_string(auth_data, "tokens", "access_token")
    auth_account_id = get_nested_string(auth_data, "tokens", "account_id")

    if not auth_data:
        print(f"{account_name}: auth file not found or invalid", file=sys.stderr)
        return 1, None

    if not auth_token:
        print(f"{account_name}: missing access_token", file=sys.stderr)
        return 1, None

    if not auth_account_id:
        print(f"{account_name}: missing account_id", file=sys.stderr)
        return 1, None

    validation_error = validate_token_inputs(
        auth_token,
        auth_account_id,
        auth_token,
        auth_account_id,
    )
    if validation_error is not None:
        return validation_error, None

    headers = {
        "Authorization": f"Bearer {auth_token}",
        "Accept": "application/json",
        "ChatGPT-Account-Id": auth_account_id,
        "Origin": "https://chatgpt.com",
        "Referer": "https://chatgpt.com/",
        "User-Agent": "Mozilla/5.0",
    }

    try:
        response = requests.get(args.chatgpt_url, headers=headers, timeout=60)
    except requests.RequestException as exc:
        print(f"Request failed: {exc}", file=sys.stderr)
        return 2, None

    if args.raw_headers:
        print("=== Headers ===")
        print_json(dict(response.headers))
        print()

    try:
        data = response.json()
    except ValueError:
        print(f"HTTP {response.status_code}", file=sys.stderr)
        print(response.text, file=sys.stderr)
        return 3, None

    error_response = handle_error_response(response, data, args.raw_json)
    if error_response is not None:
        return error_response, None

    if args.raw_json:
        print("=== Raw JSON ===")
        print_json(data)
        print()

    rate_limits = first_dict(data, "rate_limit", "rate_limits")

    if rate_limits is None:
        return 0, build_summary_row(account_name, None, None)

    five_hour, weekly = parse_rate_limits(rate_limits)
    return 0, build_summary_row(account_name, five_hour, weekly)


def main() -> None:
    args = parse_args()
    auth_paths = get_auth_paths(args.account_dir, args.account_name)
    if not auth_paths:
        print("No auth files found.", file=sys.stderr)
        sys.exit(1)

    exit_code = 0
    summary_rows: list[JSONDict] = []
    for auth_path in auth_paths:
        current_exit_code, summary_row = fetch_chatgpt_usage(auth_path, args)
        exit_code = max(exit_code, current_exit_code)
        if summary_row is not None and not args.raw_json:
            summary_rows.append(summary_row)

    if summary_rows:
        print_summary_rows(summary_rows)
    sys.exit(exit_code)


if __name__ == "__main__":
    main()

Windows 局域网访问 Ollama API 设置指南

Sat, 11 Apr 2026 16:43:52 +0800

如果你希望局域网内其他设备访问本机 Ollama API，可以按下面步骤配置。

设置监听端口

先将 Ollama 监听地址改为所有网卡：

OLLAMA_HOST=0.0.0.0:11434

打开防火墙

打开防火墙高级设置后，新建一条入站规则并放行目标端口（例如 8080）：

按下 Win + S，搜索并打开“Windows Defender 防火墙”。
点击“高级设置”。
选择“入站规则” -> “新建规则…”。
规则类型选“端口”，点击“下一步”。
选择协议（通常是 TCP），在“特定本地端口”输入要开放的端口号（例如 8080），点击“下一步”。
选择“允许连接”，点击“下一步”。
在“配置文件”中勾选“域”“专用”“公用”，点击“下一步”。
为规则命名（例如 OpenPort8080），点击“完成”。

运行 Ollama

Ollama run 模型

通过 API 访问模型

curl http://192.168.x.xxx:11434/api/generate -d '{
  "model": "gemma4",
  "prompt": "这个是什么模型?"
}'

Ollama 云模型是什么，怎么用

Thu, 09 Apr 2026 18:42:32 +0800

如果你平时用 Ollama 跑本地模型，应该很容易理解云模型。

区别只有一个核心点：
本地模型是在你的电脑上推理，云模型是在 Ollama 的云端推理，再把结果返回给你。

云模型是什么

Ollama 云模型保留了 Ollama 的调用方式，但把计算位置从本地换到了云端。

这样做的好处是：

本地硬件压力更小
更容易使用本地机器跑不动的大模型
仍然可以沿用熟悉的 Ollama 工作流

和本地模型的区别

对比项	本地模型	云模型
运行位置	本机	云端
硬件要求	高	低
延迟	更低	受网络影响
隐私性	更强	请求会发送到云端

如果你更在意隐私、低延迟和离线使用，本地模型更合适。
如果你本地硬件不够，但又想体验更大的模型，云模型更方便。

怎么识别云模型

当前 Ollama 的云模型一般会带 -cloud 后缀，例如：

`1`	`gpt-oss:120b-cloud`

可用模型列表可能会变化，实际以 Ollama 官方页面为准。

怎么用

先登录：

`1`	`ollama signin`

登录完成后，直接运行云模型：

`1`	`ollama run gpt-oss:120b-cloud`

如果你是在代码里调用，也可以配置 API Key：

`1`	`export OLLAMA_API_KEY=your_api_key`

Python 示例：

import os
from ollama import Client

client = Client(
    host="https://ollama.com",
    headers={"Authorization": "Bearer " + os.environ["OLLAMA_API_KEY"]},
)

messages = [
    {"role": "user", "content": "为什么天空是蓝色的？"}
]

for part in client.chat("gpt-oss:120b-cloud", messages=messages, stream=True):
    print(part["message"]["content"], end="", flush=True)

小结

Ollama 云模型可以理解成一句话：

命令基本没变，只是模型不在你本地跑了。

如果你的电脑带不动大模型，但你又想继续用 Ollama 的方式调用模型，云模型就是一个很直接的方案。