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 消耗通常比普通聊天高得多。

問題不只是「模型回答了一段話」，而是整個流程裡會不斷出現這些內容：

讀檔案
看日誌
調 API
返回 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，統一輸出一張摘要表。你目前登入的 ChatGPT 帳號所對應的 auth.json，通常可以在 ~/.codex/ 目錄下找到。

最關鍵的輸入

腳本通常只依賴兩項憑證：

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 的方式呼叫模型，雲模型就是一個很直接的方案。