把 claude -p 当 API 用：拿订阅跑出 API 的效果

0先说人话：默认为什么那么贵

claude -p 不是个「聊天接口」，它是整个 Claude Code 本人——一个能读写文件、跑命令、搜代码的 agent。 所以你每喊它一句，输入里其实默默塞着：

• 一整套工具说明书（Read / Write / Bash / Grep… 十几个工具的用法定义，十几 k token）；
• 一大张默认系统提示（怎么当 agent、怎么用工具、安全规矩…… 又是几 k）。

于是哪怕你只说一句「陪我聊聊天」，输入也是 约 2.7 万 token（实测）。纯聊天场景里，这些全是白烧的额度。

1需要什么设备

朴素到有点好笑：

• 一台装了 Claude Code 的电脑（macOS / Linux / Windows 都行），并且登录过你的 Claude 订阅 （命令行跑过一次 claude 登录完即可；Max 订阅额度多、最舒服）。
• 验明正身：终端敲 which claude 能打印出路径（macOS 上通常是 /opt/homebrew/bin/claude），就齐活了。
• 只给自己用：到此为止，不需要任何别的东西。
• 想让外网 / 手机也能用：再加两样——让这台机器别睡（caffeinate 或 pmset 禁睡）， 和一个内网穿透（Tailscale / cloudflared / 反向隧道）把端口送上公网。这两样是另一篇的事，本篇只管省钱。

2前端怎么接入（最小后端 + 前端）

浏览器没法直接调本机命令，得有个后端起一个 claude -p 子进程、把结果转给网页。最小可跑版：

后端（FastAPI · 省钱配置已就位）

app.pyimport json, os, subprocess
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from pydantic import BaseModel

app = FastAPI()
CLAUDE_BIN = "/opt/homebrew/bin/claude"          # which claude

# ★ 省额度的命门：纯聊天就别让它当 agent
#   --tools none     把整套工具说明书剥光（十几 k token 直接没了）
#   --system-prompt  整张系统提示「换掉」（不是 append！append 会把臃肿默认提示留着）
SYS = "你是一个温柔耐心的陪伴者，说话口语、贴心、有来有回。绝不使用任何工具、不读写文件、不执行命令，只管说话。"

class Req(BaseModel):
    prompt: str = ""

@app.post("/chat")
def chat(inp: Req):
    env = dict(os.environ)
    # 子进程环境很干净，常找不到 node/claude，手动补 PATH、HOME
    env["PATH"] = "/opt/homebrew/bin:/usr/local/bin:" + env.get("PATH", "/usr/bin:/bin")
    env["HOME"] = os.path.expanduser("~")

    def gen():
        proc = subprocess.Popen(
            [CLAUDE_BIN, "-p",
             "--tools", "none",                  # ★ 扒光工具
             "--system-prompt", SYS,             # ★ 换掉系统提示（精简人设）
             "--output-format", "stream-json",
             "--verbose",
             "--include-partial-messages",       # 少了这个就没有逐字增量
             inp.prompt],
            cwd=env["HOME"], env=env,
            stdout=subprocess.PIPE, stderr=subprocess.DEVNULL,
            text=True, bufsize=1,
        )
        try:
            for line in proc.stdout:             # 逐行读 claude 吐的 JSONL
                line = line.strip()
                if not line:
                    continue
                try:
                    j = json.loads(line)
                except Exception:
                    continue
                # 正文增量都包在 stream_event.event.content_block_delta.delta.text 里
                if j.get("type") == "stream_event":
                    d = (j.get("event") or {}).get("delta") or {}
                    if d.get("type") == "text_delta" and d.get("text"):
                        yield "data: " + json.dumps({"delta": d["text"]}, ensure_ascii=False) + "\n\n"
                # 结尾结账：把这轮 token / 缓存账单转给前端
                elif j.get("type") == "result":
                    u = j.get("usage") or {}
                    yield "data: " + json.dumps({"usage": {
                        "in": u.get("input_tokens"),
                        "cached": u.get("cache_read_input_tokens"),
                        "cacheWrite": u.get("cache_creation_input_tokens"),
                        "out": u.get("output_tokens"),
                    }}, ensure_ascii=False) + "\n\n"
        finally:
            try: proc.terminate()
            except Exception: pass
            yield "data: " + json.dumps({"done": True}) + "\n\n"

    return StreamingResponse(gen(), media_type="text/event-stream", headers={
        "X-Accel-Buffering": "no",   # 公网前面有 nginx 时，防它把 SSE 憋成一坨
        "Cache-Control": "no-cache",
    })

前端（原生 JS，边读边显）

app.jsasync function chat(prompt, onText) {
  const res = await fetch("/chat", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ prompt }),
  });
  const reader = res.body.getReader();
  const dec = new TextDecoder();
  let buf = "", text = "";
  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    buf += dec.decode(value, { stream: true });
    let nl;
    while ((nl = buf.indexOf("\n")) >= 0) {
      const line = buf.slice(0, nl).trim();
      buf = buf.slice(nl + 1);
      if (!line.startsWith("data:")) continue;
      let j; try { j = JSON.parse(line.slice(5).trim()); } catch { continue; }
      if (j.delta) { text += j.delta; onText(text); }          // 正文累加、实时刷新
      if (j.usage) console.log("这轮账单", j.usage);            // 看省了多少，见第 4 节
    }
  }
  return text;
}

// 用法
chat("陪我聊聊天", (t) => { box.textContent = t; });

想顺带把模型「开口前的真思维链」也流出来？那是另一篇专门讲的事，参见 claude-p-thinking-stream。本篇专心省钱。

3怎么省 token（订阅额度）—— 核心一招

记住两个参数的生死差别：

实测（macOS，2026-06）：

claude -p --tools none --system-prompt "你只管说话，绝不用工具。" \
  --output-format json "说一个字：好" 2>/dev/null \
| python3 -c "import sys,json;u=json.load(sys.stdin)['usage'];print('input_tokens =', u['input_tokens'])"
# → input_tokens = 183

一句话：约 2.7 万 token ➜ 183　（差着百来倍）

带上正经的人设（几百字），也就几百到一两 k token，依旧便宜得离谱。

4怎么做命中缓存（对，官方订阅也能命中）

很多人以为「提示缓存」是 API 才有的、订阅版没有。错。 claude -p 走订阅照样缓存， 省下来的 cache_read token 只按约 1/10 计费。亲手实测给你看：

# 造一段约 3000 字、逐字不变的系统提示，连打两次同样的前缀
SP=$(python3 -c "print('你是一个温柔耐心的陪伴者，说话口语、贴心、有来有回。'*120)")

# 第 1 次（建缓存）
claude -p --tools none --system-prompt "$SP" --output-format json "说：第一次" 2>/dev/null | …usage
# → creation= 3887  read= 0          （把这段前缀写进了缓存）

# 第 2 次（同一前缀，应命中）
claude -p --tools none --system-prompt "$SP" --output-format json "说：第二次" 2>/dev/null | …usage
# → creation= 137   read= 3750       （★命中！3750 token 从缓存白拿，只收约 1/10）

第二次那 read=3750 就是省下的真金白银——它没重新「读」一遍三千字的系统提示，直接从缓存里捞。

命中缓存的三条铁律

5一步到位 · 傻子版

不想看原理，照抄就行：

① 装依赖、存后端

pip install fastapi uvicorn
# 把第 2 节那个 app.py 存下来（已含 --tools none + --system-prompt 省钱配置）

② 起后端

uvicorn app:app --port 8000

③ 一行命令验证省钱 + 流式都正常

curl -sN -X POST http://127.0.0.1:8000/chat \
  -H 'Content-Type: application/json' \
  -d '{"prompt":"陪我聊聊天，说三句"}'
# 一股一股冒字 = 流式正常；最后那条 {"usage":{"in": …}} 里 in 是一两百 = 省钱配置生效

④ 想连命中缓存一起占满：把 app.py 里的 SYS 换成一段够长（≥约 1024 token）、固定不变的人设 / 世界观， 别把时间、心情这种每次会变的写进去——它就会从第二轮起一直命中缓存。

不接网页、就想在终端省着聊，一行就够：

claude -p --tools none \
  --system-prompt "你是温柔的陪伴者，只管说话，绝不使用任何工具、不读写文件、不执行命令。" \
  "陪我聊聊天"