Chi phí LLM không nằm ở giá niêm yết. Nó nằm ở cấu trúc vòng lặp. Một agent 12 bước gửi lại lịch sử ở mỗi bước trả tiền cho cùng một token nhiều lần — và nếu bạn chỉ nhìn bảng giá “$2 input / $10 output”, bạn sẽ dự toán thấp hơn thực tế vài lần, rồi ngạc nhiên vào cuối tháng.
Bài này đi qua bốn hạng mục bị tính tiền, ba phép tính đủ để dự toán một task, và những chỗ multiplier biến một request bình thường thành request đắt gấp đôi. Mọi con số dưới đây lấy từ tài liệu giá chính thức đọc ngày 2026-11-08; giá đổi theo tháng, nên hãy xem chúng là ví dụ về quan hệ, không phải hằng số.
Mục lục
Cập nhật 2026: bốn điều làm hóa đơn khác bản cũ
- Bốn hạng mục, không phải hai. Input, cached input, output, và reasoning token — reasoning được tính như output, không miễn phí.
- Ghi cache cũng tốn tiền. Anthropic tính 1,25x cho cache 5 phút và 2x cho cache 1 giờ; OpenAI tính riêng giá ghi cache theo từng dòng model.
- Long-context là bậc thang. OpenAI gấp đôi input và 1,5x output khi request vượt 272K token; xAI gấp đôi khi vượt 200K; Anthropic và Gemini phẳng ở 1M.
- Giá khuyến mãi có hạn. Gemini 4 Argon đang $2/$10 đến 2026-11-30, sau đó $4/$20; Gemini 3.8 Flash $0,75/$3,75 đến 2026-12-31, sau đó $1,50/$7,50. Đừng lập ngân hàng năm trên giá khuyến mãi.
Bốn hạng mục chi phí
Input thường là token bạn gửi mà chưa từng được cache: system prompt mới, câu hỏi mới, kết quả tool mới. Cached input là phần prefix giống hệt từng byte với lần gọi trước, được đọc với giá thấp hơn nhiều. Output là token model sinh ra, thường đắt gấp 5 lần input. Reasoning là token model sinh ra để suy luận, bị tính vào output nhưng thường được báo riêng trong usage — và đây chính là chỗ dễ đếm hai lần khi tự viết công thức tính tiền.
Giá tham khảo, USD trên 1 triệu token:
| Model | Input / cached / output | Ghi cache |
|---|---|---|
| GPT-6 Astra | $10 / $1 / $50 | $12,50 |
| GPT-6.1 Sol | $2 / $0,10 / $10 | $2,50 |
| Claude Sonnet 5.5 | $2 / $0,10 / $10 | 1,25x (5 phút) / 2x (1 giờ) |
| Claude Haiku 5.5 | $0,10 / $0,01 / $0,50 (≤100K) | 1,25x / 2x |
| Gemini 4 Argon | $2 / — / $10 (đến 2026-11-30) | implicit cache, không ghi tường minh |
Hai quan hệ đáng nhớ hơn cả con số tuyệt đối. Thứ nhất, output đắt gấp 5 lần input ở hầu hết dòng model — nên cắt output hiệu quả hơn cắt input, tính trên mỗi token. Thứ hai, cached input rẻ bằng 5–10% input thường — nên giữ prefix ổn định là đòn bẩy lớn nhất trong toàn bộ bài này.
Cache: hòa vốn ở lần dùng thứ hai, nếu prefix đủ dài
Ghi cache không miễn phí, nên câu hỏi đúng là: cần bao nhiêu lần tái sử dụng thì có lãi. Tính theo đơn vị “giá input 1x”:
- Cache 5 phút (Anthropic 1,25x, đọc 0,05x): hai request tốn 1,25 + 0,05 = 1,30 thay vì 2,00. Hòa vốn ngay từ lần thứ hai, tiết kiệm 35%.
- Cache 1 giờ (ghi 2x, đọc 0,05x): hai request tốn 2,05 — đắt hơn không cache. Ba request tốn 2,10 thay vì 3,00. Chỉ có lãi từ lần thứ ba.
- OpenAI Sol (ghi $2,50, đọc $0,10 so với input $2): cùng hình học — ghi 1,25x, đọc 0,05x, hòa vốn ở lần thứ hai.
Điều kiện thứ hai: prefix phải đủ dài. Anthropic yêu cầu tối thiểu 512 token cacheable; dưới ngưỡng đó không có gì được cache và bạn trả giá input đầy đủ. Với agent phân loại có prompt 300 token, cache vô nghĩa. Với agent có system prompt + tool schema 8.000 token, cache là khoản tiết kiệm lớn nhất và ổn định nhất.
Điều kiện thứ ba, hay bị bỏ: prefix phải byte-stable. Chèn một timestamp, một tenant ID, hay một bản tóm tắt mới vào đầu prompt là mất cache của toàn bộ phần sau. Cấu trúc đúng: phần bất biến trước, phần thay đổi sau.
Ví dụ 1: một bước của agent
Một lượt gọi GPT-6.1 Sol với 60K input, trong đó 50K là cached, output 4K (gồm 1K reasoning):
- 10K input thường × $2/1M = $0,02
- 50K cached × $0,10/1M = $0,005
- 4K output × $10/1M = $0,04
- Tổng: $0,065
Không có cache, cùng lượt đó tốn 60K × $2/1M = $0,12 cộng $0,04 output, tức $0,16. Cache tiết kiệm khoảng 59% cho một bước — và tỷ lệ này giữ nguyên qua hàng nghìn bước, miễn prefix không đổi.
Ví dụ 2: vòng lặp nhân chi phí
Đây là phần làm dự toán sai nhiều nhất. Giả sử agent chạy 12 bước, mỗi bước gửi lại toàn bộ lịch sử, input tăng dần từ 8K đến 52K, output mỗi bước 1,5K (gồm reasoning). Tổng input thực trả tiền là 8 + 12 + … + 52 = 360K token, không phải 52K của bước cuối.
- Không cache: 360K × $2/1M = $0,72 input + 18K × $10/1M = $0,18 output → $0,90/task.
- Cache 80% input (prefix ổn định): 288K cached × $0,10 = $0,0288 + 72K × $2 = $0,144 + $0,18 output → $0,35/task.
Cùng một task, chênh gần 2,6 lần, chỉ vì cấu trúc prompt. Với 10.000 task/tháng, khoản chênh là $5.500 — đủ lớn để biến một dự án từ có lãi thành lỗ.
Và đây là lúc multiplier long-context xuất hiện. Nếu bước cuối của agent chạm 280K input và gọi OpenAI, toàn bộ request đó bị 2x input và 1,5x output. Một bước vượt ngưỡng có thể tốn bằng nhiều bước bình thường cộng lại. Với xAI ngưỡng là 200K. Với Claude Haiku 5.5, ngưỡng là 100K nhưng giá nhảy 5 lần cho toàn request ($0,10/$0,50 thành $0,50/$2,50). Đây là lý do phải log độ dài request, không chỉ log tổng chi phí.
Ví dụ 3: chiết khấu batch và ưu tiên
Batch/Flex giảm khoảng 50% ở OpenAI, Anthropic, Google và Mistral, nhưng là xử lý bất đồng bộ — phù hợp cho backfill, eval, phân loại hàng loạt, không phù hợp cho agent tương tác. Ngược lại, Google Priority khoảng 1,8x và OpenAI Fast 2x là giá của độ trễ thấp; regional endpoint cộng thêm khoảng 10%.
Quy tắc chọn: tác vụ có người chờ thì trả giá ưu tiên; tác vụ chạy nền thì đẩy sang batch. Đừng dùng batch cho eval cần kết quả ngay trong CI, và đừng dùng Fast cho job tổng hợp chạy qua đêm.
Công thức tính tiền, đúng thứ tự
Đoạn code dưới tính chi phí theo từng request rồi cộng lại — không cộng token của cả task rồi mới áp ngưỡng, vì ngưỡng long-context áp theo từng request.
# File: cost.py
from dataclasses import dataclass
@dataclass(frozen=True)
class Price:
input: float # USD / 1M token
cached: float
output: float
threshold: int | None = None # ngưỡng long-context
in_mult: float = 1.0
out_mult: float = 1.0
SOL = Price(input=2.00, cached=0.10, output=10.00,
threshold=272_000, in_mult=2.0, out_mult=1.5)
def one_request(p: Price, input_tokens: int,
cached_tokens: int, output_tokens: int) -> float:
if input_tokens - cached_tokens < 0:
raise ValueError("cached_tokens phải là subset của input_tokens")
mi = mo = 1.0
if p.threshold and input_tokens > p.threshold:
mi, mo = p.in_mult, p.out_mult # áp cho TOÀN BỘ request
uncached = input_tokens - cached_tokens
return (uncached * p.input * mi
+ cached_tokens * p.cached * mi
+ output_tokens * p.output * mo) / 1_000_000
def task_cost(p: Price, requests: list[tuple[int, int, int]]) -> float:
return sum(one_request(p, *r) for r in requests)
# 12 bước, input 8K..52K, cache 80%, output 1,5K mỗi bước
reqs = [(i * 4_000, int(i * 4_000 * 0.8), 1_500) for i in range(2, 14)]
print(round(task_cost(SOL, reqs), 4)) # ~ 0.3528
print(round(task_cost(SOL, [(i, 0, o) for i, _, o in reqs]), 4)) # ~ 0.90
print(round(one_request(SOL, 280_000, 0, 4_000), 4)) # 1.18 (2x input, 1.5x output)
Ba dòng cuối là ba phép so sánh nên chạy trong CI hoặc trong dashboard: có cache, không cache, và một request vượt ngưỡng. Dòng thứ ba cho $1,18 cho 280K input + 4K output, so với $0,60 cho cùng lượng token nhưng nằm dưới ngưỡng 272K — gần gấp đôi chỉ vì 8K token vượt rào.
Ngân sách theo tenant và theo task
Chi phí trên mỗi lần gọi là chỉ số vô nghĩa. Chỉ số đúng là chi phí trên một task thành công, và với sản phẩm nhiều khách hàng, là chi phí trên tenant. Cách làm:
- Ghi usage theo bốn hạng mục (input, cached, output, reasoning), gắn nhãn tenant, task type, và feature.
- Đặt ngân sách mỗi task (ví dụ $0,50) và ngân sách tháng mỗi tenant; vượt ngưỡng thì hạ model hoặc rút ngắn context, không phải “cứ chạy”.
- Đặt global cap và spend limit ở tầng gateway; giới hạn số bước và số token mỗi phiên.
- Khi kill switch bật, thu hồi credential của tool — dừng process không đủ, vì process khác có thể tiếp tục gọi.
Chi phí task cũng phải tính cả lần thất bại. Nếu 30% task phải retry một lần, chi phí thực trên task thành công cao hơn giá một lần chạy khoảng 30%. Đây là lý do eval chất lượng và tối ưu chi phí không thể tách rời: agent trả lời sai rẻ hơn agent trả lời đúng một lần, nhưng đắt hơn nhiều nếu tính đến retry, escalate và thời gian người dùng.
Semantic cache: tiết kiệm thật, rủi ro thật
Semantic cache trả về câu trả lời đã lưu khi truy vấn mới đủ giống truy vấn cũ. Với FAQ, tra cứu chính sách, hoặc các bước lặp lại trong agent, nó cắt được phần lớn chi phí. Với dữ liệu cá nhân hoá, nó là lỗ hổng: hai người dùng khác nhau có thể nhận cùng một câu trả lời chứa thông tin của người kia.
Bốn điều kiện để dùng an toàn: key cache phải gồm (tenant, model, prompt hash, tool set); invalidate khi bất kỳ thành phần nào đổi; không bao giờ cache câu trả lời phụ thuộc quyền truy cập hoặc dữ liệu cá nhân; và đặt ngưỡng similarity đủ cao, đo bằng eval chứ bằng cảm giác. Cache ngữ nghĩa đi lệch dần khi dữ liệu nguồn thay đổi — nếu không có TTL, bạn đang phục vụ câu trả lời của tháng trước với giá của hôm nay.
Cũng đừng nhầm với prompt cache. Prompt cache tái sử dụng phần tính toán trên cùng một prefix; nó không trả về câu trả lời cũ và không có rủi ro rò rỉ nội dung. Đây là công cụ nên dùng trước, và gần như luôn có lãi với agent có system prompt dài.
Lỗi phổ biến
- Dùng giá của bản tài liệu cũ. Bảng GPT-4o/Claude 3 trong bài viết cũ không còn liên quan; giá hiện tại khác cả về cấu trúc lẫn mức.
- Bỏ qua giá ghi cache. Với prefix ngắn hoặc cache 1 giờ dùng một lần, cache làm tăng chi phí.
- Đếm reasoning hai lần. Reasoning là subset của output ở nhiều API; cộng thêm lần nữa là sai 20–50%.
- Cộng token cả task rồi mới áp ngưỡng long-context. Ngưỡng áp theo request; cách tính gộp cho kết quả sai và thường sai theo hướng lạc quan.
- Tối ưu giá/token thay vì giá/task. Model rẻ nhưng cần 3 lần retry đắt hơn model đắt chạy đúng một lần.
- Đặt ngân sách theo tháng nhưng không có cap theo ngày. Một vòng lặp lỗi có thể tiêu hết ngân sách tháng trong một buổi tối.
Checklist
- Log bốn hạng mục usage theo tenant, task và feature; không log mỗi tổng.
- Kiểm tra prefix có byte-stable không, và tỷ lệ cached/input có tụt bất thường không.
- Tính chi phí theo từng request, có multiplier long-context; đặt cảnh báo khi request vượt ngưỡng.
- Đặt ngân sách mỗi task và cap ngày; hạ model trước khi hạ chất lượng xuống dưới eval gate.
- Chuyển backfill/eval sang batch; giữ tier ưu tiên cho tác vụ có người chờ.
- Với semantic cache: key theo tenant + model + prompt hash + tool set, có TTL và eval riêng.
2027 sẽ chứng kiến chi phí được quản lý như SLO: ngân sách theo task, cảnh báo theo tenant, và routing tự động giữa model rẻ và model mạnh dựa trên độ tin cậy của output. Nhưng phần lớn khoản tiết kiệm vẫn đến từ ba việc nhàm chán — prefix ổn định, output ngắn, và không gửi lại thứ đã gửi.
Bài liên quan
- Cửa sổ ngữ cảnh và độ dài tối đa — vì sao request vượt ngưỡng lại đắt gấp đôi.
- Ảnh hưởng của tokenization — token nào thực sự vào hóa đơn.
- Lựa chọn LLM cho suy luận và lập kế hoạch — chọn model theo chi phí trên task.
- Giám sát agent với Langfuse, Helicone và OpenLLMetry — nơi đặt dashboard chi phí.