Token ใน Claude คืออะไรและวิธีคำนวณค่าใช้จ่าย Claude Code

Token ใน Claude คืออะไร

Token คือหน่วยของข้อความที่ Claude ใช้ในการอ่านและเขียน โดยเป็นส่วนหนึ่งของคำ ซึ่งมีขนาดประมาณ 3.5 ตัวอักษรภาษาอังกฤษ ตัวเลขนี้มาจากอภิธานศัพท์ของ Anthropic เอง และเมื่อนับรวมช่องว่างและเครื่องหมายวรรคตอนแล้ว จะได้จำนวนมากกว่า 1 token ต่อคำ ดังนั้นข้อความร้อยแก้ว 1,000 คำจึงมีจำนวนเกิน 1,300 tokens อย่างแน่นอน สำหรับโค้ดจะมีจำนวน token ต่อบรรทัดสูงกว่า เนื่องจากวงเล็บ ตัวดำเนินการ เครื่องหมายขีดล่าง และการย่อหน้าจะถูกแบ่งเป็นจำนวน token ต่อตัวอักษรมากกว่าภาษาอังกฤษ ทำให้ไฟล์ซอร์สโค้ดขนาดไม่กี่ร้อยบรรทัดมักจะมีขนาดหลายพัน tokens ส่วนไฟล์ขนาด 2,000 บรรทัดที่ agent ตัดสินใจอ่านนั้น จะมีมูลค่าการใช้งานสูงถึงหลักหมื่น tokens ก่อนที่จะมีการเขียนโค้ดใหม่แม้แต่บรรทัดเดียว

มีสองสิ่งที่เกี่ยวกับ tokenizer ที่มักทำให้เกิดความเข้าใจผิด ประการแรกคือ tokenizer ขึ้นอยู่กับรุ่นของโมเดล โดย ณ เดือนกรกฎาคม 2026 รุ่น Opus 4.7 ขึ้นไป, Sonnet 5 และ Fable 5 ใช้ tokenizer รุ่นใหม่ที่สร้างจำนวน tokens มากกว่าโมเดล Claude รุ่นก่อนหน้าประมาณ 30% สำหรับข้อความเดียวกัน (จำนวนที่เพิ่มขึ้นจริงจะแตกต่างกันไปตามเนื้อหา) ซึ่งส่งผลต่อการประมาณการงบประมาณด้าน tokens ของคุณ แม้ว่าราคาต่อ token จะไม่ได้ปรับเพิ่มขึ้นตามก็ตาม ประการที่สองคือ tiktoken ซึ่งเป็นไลบรารีที่บล็อกส่วนใหญ่นิยมใช้ เป็น tokenizer ของ OpenAI ซึ่งจะนับจำนวน tokens ต่ำกว่าความเป็นจริงสำหรับ Claude ประมาณ 15–20% ในข้อความทั่วไป และจะยิ่งคลาดเคลื่อนมากขึ้นในกรณีของโค้ด วิธีเดียวที่เชื่อถือได้ในการนับจำนวนคือการใช้ endpoint count_tokens ซึ่งจะอธิบายไว้ด้านล่างนี้

เหตุผลที่เซสชันการเขียนโค้ดของคุณมีค่าใช้จ่ายตามที่ปรากฏ

ใบแจ้งหนี้ของ Claude ทุกฉบับ ไม่ว่าจะเป็นใบแจ้งหนี้ API หรือขีดจำกัดของการสมัครสมาชิก ล้วนขึ้นอยู่กับหน่วยวัดเดียวคือจำนวน tokens ขาเข้าและขาออก หน้าแสดงราคาทำให้ดูเหมือนเป็นเรื่องง่าย โดยระบุราคาต่อล้าน tokens ขาเข้าและขาออก แต่สิ่งที่ไม่ได้บอกไว้คือ ในเซสชันการเขียนโค้ดแบบ agentic นั้น ฝั่งขาเข้าจะมีการใช้งานสูงกว่าที่คาดการณ์ไว้มาก เนื่องจากบทสนทนาทั้งหมดจะถูกส่งซ้ำในทุกรอบการโต้ตอบ ผมขายโครงสร้างพื้นฐานแบบคิดค่าบริการตามการใช้งานมา 15 ปี และ tokens เป็นหน่วยวัดแรกที่ผมพบว่าลูกค้าส่วนใหญ่ไม่สามารถระบุได้ชัดเจนว่าอะไรเป็นตัวขับเคลื่อนค่าใช้จ่าย นี่คือบทเรียนเกี่ยวกับการอ่านหน่วยวัด: สิ่งใดที่นับเป็นขาเข้าและขาออกในเซสชันแบบ agentic, เหตุใดลูปการส่งข้อมูลซ้ำจึงมีราคาแพง, เหตุใด prompt caching จึงเปลี่ยนสมการคำนวณ และปัจจัยใดที่ส่งผลต่อตัวเลขค่าใช้จ่ายอย่างแท้จริง

ทุกอย่างคืออินพุต: สิ่งที่มิเตอร์นับจริง

ผู้คนมักเข้าใจว่าตนเองจ่ายเงินสำหรับโค้ดที่ Claude เขียนขึ้น ในเซสชันแบบเอเจนต์ (agentic session) นั่นเป็นเพียงรายการค่าใช้จ่ายส่วนน้อยเท่านั้น โทเค็นอินพุต (input tokens) ซึ่งมีอัตราค่าบริการถูกกว่าแต่มีปริมาณมหาศาลกว่ามาก ประกอบด้วย:

• System prompt: คำสั่งควบคุมการทำงานของ Claude Code รวมถึง CLAUDE.md และไฟล์หน่วยความจำของคุณ ซึ่งจะถูกโหลดเมื่อเริ่มเซสชันและปรากฏอยู่ในทุกคำขอหลังจากนั้น
• คำจำกัดความของเครื่องมือ (Tool definitions): สคีมาของเครื่องมือทุกอย่างที่เอเจนต์สามารถเรียกใช้ได้ MCP server ที่คุณเชื่อมต่อ ทุกตัวจะเพิ่มภาระงานส่วนนี้ แม้ว่าปัจจุบัน Claude Code จะใช้วิธีเลื่อนการโหลดคำจำกัดความของเครื่องมือ MCP แบบเต็มรูปแบบออกไปโดยค่าเริ่มต้น ทำให้มีเพียงชื่อเครื่องมือเท่านั้นที่อยู่ในบริบทจนกว่าจะมีการเรียกใช้เครื่องมือเป็นครั้งแรก ซึ่งช่วยลดค่าใช้จ่ายลงได้บ้างแต่ไม่ได้ทำให้หมดไป
• ไฟล์ทุกไฟล์ที่เอเจนต์อ่าน: การ Read ไฟล์ซอร์สโค้ดจะนำเนื้อหาทั้งหมดเข้าสู่บริบทและคงอยู่ที่นั่น
• ผลลัพธ์จากเครื่องมือทุกอย่าง: การรันการทดสอบ, ผลลัพธ์จาก grep, ข้อความที่แสดงในเทอร์มินัล, log ของการ build ทั้งหมดนี้จะถูกนับเป็นโทเค็นอินพุต ชุดการทดสอบที่ล้มเหลวและพิมพ์ข้อความออกมา 8,000 บรรทัด จะทำให้คุณถูกเรียกเก็บเงินเท่ากับราคาหนังสือเล่มเล็กหนึ่งเล่ม
• บทสนทนาทั้งหมดที่ผ่านมา ซึ่งจะถูกส่งซ้ำในทุกเทิร์น: หัวข้อนี้มีความสำคัญจนควรแยกเป็นส่วนเฉพาะของตัวเอง

การส่งข้อมูลซ้ำที่ไม่มีใครคำนึงถึงต้นทุน

Claude API เป็นแบบ stateless ซึ่งหมายความว่าระบบจะไม่จดจำ session ระหว่างการร้องขอใดๆ ทั้งสิ้น ดังนั้นในรอบที่ 2 ไคลเอนต์จะต้องส่งข้อมูลของรอบที่ 1 พร้อมคำตอบของรอบนั้นและข้อความใหม่ของคุณไปด้วย เมื่อถึงรอบที่ 50 ระบบจะต้องส่งข้อมูลตั้งแต่รอบที่ 1 ถึง 49 ใหม่ทั้งหมด รวมถึงไฟล์ที่อ่าน ผลลัพธ์จากเครื่องมือ (tool result) และ diff ทั้งหมด บวกกับข้อมูลของรอบที่ 50 โมเดลจะอ่านบันทึกการสนทนาทั้งหมดใหม่ทุกครั้ง และโทเค็นที่ถูกอ่านซ้ำเหล่านั้นทั้งหมดจะถูกคิดเป็นค่าใช้จ่ายในส่วนของ input

ผลที่ตามมาคือ ต้นทุนต่อรอบจะเพิ่มขึ้นในลักษณะเชิงเส้นตามความยาวของ session และต้นทุนรวมของ session จะเพิ่มขึ้นในลักษณะเชิงกำลังสอง ข้อความที่เคยมีค่าใช้จ่ายเพียงครึ่งเซนต์ในรอบที่ 3 อาจมีราคาสูงขึ้นถึง 20 เท่าในรอบที่ 60 สำหรับคำถามบรรทัดเดียวเท่าเดิม เนื่องจากต้องแบกรับภาระข้อมูลจาก 60 รอบการสนทนา นี่คือข้อเท็จจริงเพียงประการเดียวที่อธิบายสาเหตุของตั๋วแจ้งปัญหา "ทำไมค่าใช้จ่ายของฉันถึงสูงมาก" ได้เกือบทั้งหมด และนี่ไม่ใช่ลักษณะเฉพาะของ Claude เท่านั้น แต่ผลิตภัณฑ์ LLM ทุกตัวที่ให้ความรู้สึกว่ามีสถานะ (stateful) แท้จริงแล้วคือ stateless API ที่ทำงานอยู่บนลูปการส่งข้อมูลซ้ำทั้งสิ้น

ผลลัพธ์: สิ่งที่คุณเห็น พร้อมกับกระบวนการคิดที่คุณไม่เห็น

โทเค็นขาออก (Output tokens) เป็นส่วนที่มีค่าใช้จ่ายสูง โดยมีอัตราสูงกว่าโทเค็นขาเข้าถึง 5 เท่าในกลุ่มผลิตภัณฑ์ปัจจุบัน (ณ เดือนกรกฎาคม 2026 ราคาอยู่ที่ $5/$25 สำหรับ Opus 4.8, $3/$15 สำหรับ Sonnet 5 และ $1/$5 สำหรับ Haiku 4.5) ผลลัพธ์นี้รวมถึงข้อความและโค้ดที่ Claude สร้างขึ้น และ โทเค็นการคิด (thinking tokens) ซึ่งเป็นกระบวนการใช้เหตุผลภายในที่โมเดลทำก่อนจะตอบคำถาม มีข้อเท็จจริงสองประการที่ต้องทราบในส่วนนี้: การคิดจะถูกเรียกเก็บเงินในอัตราขาออกและนับรวมใน max_tokens ดังนั้นการตอบกลับของ API ที่สิ้นสุดลงด้วย stop_reason: "max_tokens" และคำตอบที่ถูกตัดทอน มักหมายความว่ากระบวนการคิดได้ใช้โควตาจนหมดก่อนที่จะได้คำตอบ และในโมเดลปัจจุบัน สรุปการใช้เหตุผลอาจไม่แสดงให้เห็นเลย โดย Opus 4.8, Sonnet 5 และ Fable 5 จะละส่วนนี้ไว้เป็นค่าเริ่มต้น แต่กระบวนการคิดยังคงเกิดขึ้นและถูกเรียกเก็บเงินตามปกติ สิ่งที่มองไม่เห็นไม่ได้หมายความว่าฟรี

Claude Code เปิดใช้งานการคิดแบบขยาย (extended thinking) เป็นค่าเริ่มต้น เนื่องจากช่วยปรับปรุงงานหลายขั้นตอนได้อย่างเห็นผลชัดเจน และโควตาเริ่มต้นอาจสูงถึงหลายหมื่นโทเค็นต่อคำขอ สำหรับงานที่ง่ายกว่า คุณสามารถลดระดับลงได้: ปรับระดับความพยายามให้ต่ำลงด้วย /effort หรือใน /model หรือปรับการตั้งค่าการคิดใน /config นี่คือกลไกการควบคุมต้นทุนที่แท้จริง ไม่ใช่ความเชื่อที่ไม่มีมูล

การทำ Prompt caching เปลี่ยนสมการต้นทุน

Prompt caching คือเหตุผลที่ลูปการส่งข้อมูลซ้ำไม่ทำให้ทุกคนล้มละลาย API สามารถแคชส่วนนำของ prompt, system prompt, นิยามของเครื่องมือ, ประวัติการสนทนา และข้อมูลอื่นๆ ที่คงที่เอาไว้ได้ และในการร้องขอครั้งถัดไป ระบบจะดึงข้อมูลจากแคชมาใช้ในราคาที่ถูกลงมาก ณ เดือนกรกฎาคม 2026 ตัวคูณราคาคือ: การ เขียน แคชมีค่าใช้จ่าย 1.25 เท่าของอัตรา input พื้นฐาน (2 เท่าสำหรับรุ่น 1 ชั่วโมง) และการ อ่าน แคชมีค่าใช้จ่าย 0.1 เท่า การเขียนมีราคาสูงกว่าปกติ แต่การอ่านได้รับส่วนลดถึง 90% การอ่านเพียงครั้งเดียวก็คุ้มค่ากับส่วนต่างราคาของการเขียนที่เก็บไว้ 5 นาทีแล้ว

Claude Code จัดการการแคชให้คุณโดยอัตโนมัติ และในเซสชันที่ทำงานปกติ ข้อมูลส่วนใหญ่ที่ส่งซ้ำจะถูกดึงมาจากแคช แต่แคชเริ่มต้นจะมีอายุการใช้งานเพียง 5 นาที นับจากการใช้งานครั้งล่าสุด หากคุณลุกไปดื่มกาแฟนานเกินไปแล้วกลับมาส่งข้อความ แคชจะหมดอายุลง และส่วนนำทั้งหมดที่สะสมไว้จะต้องถูกเขียนใหม่ที่ราคา 1.25 เท่า แทนที่จะเป็นการอ่านที่ราคา 0.1 เท่า ในเซสชันขนาด 150K-token การส่งข้อความครั้งเดียวหลังจากแคชหมดอายุจะมีราคาสูงกว่าการส่งข้อความแบบแคชพร้อมใช้งานถึงกว่าสิบเท่า นี่คือผลลัพธ์ที่ขัดกับความรู้สึกซึ่งควรทำความเข้าใจไว้: การทำงานแบบหยุดพักแล้วกลับมาทำต่ออาจมีต้นทุนสูงกว่าการทำงานต่อเนื่อง เพราะทุกช่วงเวลาที่หยุดพักนานเกินค่า TTL จะเปลี่ยนการส่งข้อความครั้งถัดไปของคุณจากการอ่านราคาถูกเป็นการเขียนใหม่ราคาแพง ควรทำงานเป็นช่วงๆ อย่าค่อยๆ ส่งข้อความในเซสชันขนาดใหญ่ทีละข้อความทุกๆ 10 นาที

หากคุณเรียกใช้ API จาก แอปพลิเคชันของคุณเองบน VPS คุณจะไม่ได้รับสิทธิประโยชน์นี้โดยอัตโนมัติ และความผิดพลาดที่พบบ่อยคือการแทรก timestamp หรือ request ID ลงใน system prompt ซึ่งจะทำให้ไบต์ส่วนนำเปลี่ยนไปในทุกการร้องขอและปิดการใช้งานแคชโดยไม่รู้ตัว สัญญาณที่บ่งบอกคือค่า usage.cache_read_input_tokens ที่แสดงเป็นศูนย์ในการเรียกใช้งานที่ดูเหมือนกันทุกประการ

สูตรคำนวณพร้อมตัวอย่างการใช้งาน

อย่าไปเชื่อใครที่บอกว่า "เซสชันหนึ่งราคา $X" เพราะค่าใช้จ่ายของเซสชันมีความแตกต่างกันได้ถึงสองเท่าตัว สิ่งที่เชื่อถือได้คือสูตรนี้:

turn cost = (uncached input      x base input price)
          + (cache writes        x 1.25 x base input price)
          + (cache reads         x 0.10 x base input price)
          + (output incl. thinking x output price)

session cost = sum over all turns

ตัวอย่างการคำนวณบน Claude Opus 4.8 ซึ่ง ณ เดือนกรกฎาคม 2026 มีราคาอยู่ที่ $5 ต่อล้าน input tokens และ $25 ต่อล้าน output tokens สำหรับการโต้ตอบช่วงกลางเซสชันที่มี context สะสมอยู่ 80,000 tokens โดยแบ่งเป็น: อ่านจาก cache 75,000 tokens, เขียนลง cache ใหม่ 3,000 tokens, input ใหม่ที่ไม่ได้ cache 2,000 tokens และ output 1,500 tokens (รวมการคิดวิเคราะห์)

• การอ่านจาก cache: 75,000 × $0.50/M = $0.0375
• การเขียนลง cache: 3,000 × $6.25/M = $0.019
• Input ที่ไม่ได้ cache: 2,000 × $5/M = $0.010
• Output: 1,500 × $25/M = $0.0375

รวมเป็นเงินประมาณ $0.10 ต่อการโต้ตอบหนึ่งครั้ง หากมีการโต้ตอบแบบนี้ 50 ครั้ง จะมีค่าใช้จ่ายประมาณ $5 ในทางกลับกัน หากเป็นการโต้ตอบเดิมหลังจาก cache หมดอายุ จะต้องเขียนข้อมูลทั้งหมด 80,000 tokens ใหม่ในราคา $6.25/M ซึ่งคิดเป็น $0.50 ก่อนรวมค่า output หรือประมาณ 5 เท่าของค่าใช้จ่ายเมื่อ cache ยังทำงานอยู่ ทั้งที่ได้ผลลัพธ์เท่ากัน ส่วนต่างนี้คือหัวใจสำคัญของการทำ caching ทั้งหมด และการคำนวณทั้ง 4 บรรทัดนี้เป็นวิธีเดียวที่ซื่อตรงในการเปรียบเทียบผู้ให้บริการแต่ละราย เพราะราคาหน้าเว็บมักไม่รวมค่าอ่าน cache และค่าการคิดวิเคราะห์ ซึ่งเมื่อนำไปทดสอบกับงานจริง 3 งาน จะเห็นได้ชัดว่า ค่าใช้จ่ายของ Claude สูงหรือต่ำกว่า OpenAI อย่างไร

หากคุณต้องการทำความเข้าใจหน่วยการเรียกเก็บเงินมากกว่าแค่การโต้ตอบครั้งเดียว จำนวนหนึ่งล้าน tokens คิดเป็นกี่หน้า กี่ไฟล์ และกี่ดอลลาร์ จะช่วยให้คุณเห็นภาพการคำนวณในระดับที่ใหญ่ขึ้น สำหรับการประมาณการเบื้องต้น: ข้อมูลจาก Anthropic สำหรับการใช้งาน Claude Code ในองค์กร ณ เดือนกรกฎาคม 2026 มีค่าใช้จ่ายเฉลี่ยประมาณ $13 ต่อนักพัฒนาต่อวันที่มีการใช้งาน หรือประมาณ $150–250 ต่อเดือน โดยผู้ใช้ 90% มีค่าใช้จ่ายไม่เกิน $30 ต่อวัน ค่าใช้จ่ายจริงของคุณขึ้นอยู่กับการเลือกรุ่นโมเดล, การจัดการเซสชัน และขนาดของ codebase ซึ่งเป็นเหตุผลว่าทำไมปัจจัยต่างๆ ด้านล่างนี้จึงมีความสำคัญ

Seeing your own usage

In Claude Code, the command is /usage (/cost still works, it's an alias). The Session block at the top shows token statistics and a locally computed cost estimate for the current session; on subscription plans the same screen shows your plan-limit bars and a breakdown attributing recent usage to skills, subagents, plugins, and individual MCP servers. For authoritative billing on API accounts, the usage page in the Claude Console is the source of truth, the CLI figure is an estimate. /context draws a colored grid of what's occupying the context window, system prompt, tools, MCP definitions, files, history, and is the fastest way to spot a bloated CLAUDE.md or a chatty MCP server; pass all to expand the full per-item breakdown.

From the API, every response tells you exactly what happened:

response = client.messages.create(model="claude-sonnet-5", max_tokens=2048,
                                  messages=messages)
u = response.usage
total_prompt = u.input_tokens + u.cache_creation_input_tokens + u.cache_read_input_tokens
print(f"uncached={u.input_tokens} written={u.cache_creation_input_tokens} "
      f"read={u.cache_read_input_tokens} output={u.output_tokens}")

Note that input_tokens is only the uncached remainder, the true prompt size is the sum of all three input fields. An agent that ran for an hour showing input_tokens: 4000 isn't cheap; the other 200,000 tokens were served from cache. To estimate before you send, use the token-counting endpoint, it's free to call, sits on its own rate limit, and counts with the tokenizer of whichever model you name (treat the result as a close estimate; billing reflects the real request):

count = client.messages.count_tokens(model="claude-sonnet-5",
                                     messages=[{"role": "user", "content": big_file}])
print(count.input_tokens)

Never tiktoken, for the reason above.

แผนการสมัครสมาชิกเทียบกับการจ่ายตามการใช้งานจริง

กลไกการทำงานในคู่มือนี้เหมือนกันทุกประการ ต่างกันเพียงวิธีการชำระเงินเท่านั้น หากใช้ API key ทาง Anthropic จะเรียกเก็บเงินแบบจ่ายตามการใช้งานจริง (pay-as-you-go) ตามจำนวน token ในอัตราที่ประกาศไว้ ตัวเลขทั้งหมดข้างต้นคือมูลค่าเงินจริง มิเตอร์การใช้งานจะเริ่มเดินเร็วกว่าที่หลายคนคาดไว้ เนื่องจากไม่มีระดับการใช้งานฟรีให้เลือกใช้ มีเพียงเครดิตจำนวนเล็กน้อยเมื่อสมัครสมาชิกและ endpoint บางรายการที่ไม่คิดค่าใช้จ่าย ซึ่งเป็น สิ่งที่บัญชี API ใหม่ได้รับจริงก่อนที่คุณจะเพิ่มบัตรเครดิตในระบบ สำหรับการสมัครสมาชิก Claude (Pro, Max, Team, Enterprise) การใช้งาน Claude Code จะหักจากโควตาที่รวมอยู่ในแผนของคุณแทน โดย ณ เดือนกรกฎาคม 2026 โควตาดังกล่าวจะเป็นหน้าต่างการใช้งานแบบหมุนเวียน 5 ชั่วโมงและหน้าต่างรายสัปดาห์ ซึ่งใช้ร่วมกันระหว่างโมเดลต่างๆ และการแชทบน claude.ai โดยตัวเลข /usage ดอลลาร์นั้นเป็นเพียงข้อมูลประกอบไม่ใช่ยอดเรียกเก็บเงิน หากใช้งานจนเต็มหน้าต่างเวลา คุณจะเห็นข้อความ "You've hit your session limit" หรือ "You've hit your weekly limit" พร้อมเวลาที่จะรีเซ็ต และการสลับโมเดลด้วย /model จะไม่ช่วยให้กลับมาใช้งานได้อีกครั้ง เนื่องจากหน้าต่างการใช้งานถูกใช้ร่วมกันทุกโมเดล หน้าต่างเหล่านี้ผูกติดกับบัญชีผู้ใช้ไม่ใช่ตัวไคลเอนต์ที่คุณกำลังใช้งานอยู่ ซึ่งเป็นเรื่องที่ควรทราบหากคุณกำลังศึกษาว่า สิ่งใดทำงานแบบ native บน Linux และแผนใดครอบคลุมการใช้งานในส่วนไหนบ้าง การทราบว่าคุณใช้งานหน้าต่างเวลาใดจนเต็มจะเป็นตัวกำหนดระยะเวลารอคอยและสิ่งที่คุณควรทำในระหว่างนั้น ดังนั้นจึงควรทราบ ทางเลือกของคุณเมื่อพบข้อจำกัดระหว่างการทำงาน แผนการใช้งานสามารถเปิดใช้งานเครดิตเพิ่มเติมได้ ซึ่งจัดการผ่าน /usage-credits เพื่อซื้อสิทธิ์การใช้งานเกินเพดานที่กำหนดไว้ ผมจงใจไม่ระบุโควตาของแต่ละแผนไว้ เนื่องจากเป็นตัวเลขที่มีการเปลี่ยนแปลงบ่อยที่สุดในหัวข้อนี้ ดังนั้นโปรดตรวจสอบที่ claude.com/pricing และแถบสถานะ /usage ของคุณเองแทน กลไกของ token ยังคงมีความสำคัญแม้ในการสมัครสมาชิก เพราะเซสชันที่สิ้นเปลืองจะทำให้โควตาของคุณหมดลงเช่นเดียวกับการเสียเงินจริง สำหรับรายละเอียดด้านการสมัครสมาชิก โปรดดู แผน Claude ใดที่เหมาะสมกับการใช้งานของคุณ

กลไกที่ได้ผลจริง

• กำหนดขอบเขตสิ่งที่ agent อ่าน "แก้ไขบั๊กการตรวจสอบใน auth.py" จะอ่านไฟล์เดียว แต่ "ปรับปรุง codebase นี้" จะอ่านถึงสี่สิบไฟล์ รักษา CLAUDE.md ให้กระชับเนื่องจากมีการโหลดเข้าทุกเซสชัน ดังนั้นให้เก็บไว้เฉพาะสิ่งที่จำเป็น และย้ายคำสั่งเฉพาะสำหรับ workflow ไปไว้ในทักษะที่โหลดเมื่อต้องการใช้งาน
• ชัดเจนและกะทัดรัด /clear ระหว่างงานที่ไม่เกี่ยวข้องกัน บริบทที่ค้างอยู่จะถูกส่งซ้ำและคิดเงินใหม่ในทุกข้อความถัดไป ภายในงานยาวหนึ่งงาน /compact Focus on the failing tests and the diff จะสรุปประวัติย่อลงและช่วยให้คุณไม่ต้องเผชิญกับปัญหาการใช้ token แบบทวีคูณ (quadratic curve)
• เลือกขนาดโมเดลให้เหมาะสม Sonnet จัดการงานเขียนโค้ดส่วนใหญ่ได้ ที่ราคา $2/$10 ต่อล้าน token ตามราคาแนะนำ ณ เดือนกรกฎาคม 2026 (ราคาเต็ม $3/$15 เทียบกับ Opus ที่ $5/$25) และ Haiku ที่ราคา $1/$5 เป็นเครื่องมือที่เหมาะสมสำหรับงานย่อยเชิงกลไก เช่น การคัดแยก log ส่วน Fable 5 อยู่ที่ปลายอีกด้านหนึ่งในราคา $10/$50 ซึ่งแพงกว่า Opus สองเท่าในทุกด้าน ดังนั้นจึงควรทราบว่า งานใดบ้างที่คุ้มค่ากับราคานี้ ก่อนที่คุณจะเลือกใช้สำหรับงานทั่วไป /model สามารถสลับโมเดลระหว่างเซสชันได้
• กรอง output ที่ยาวเกินไปล่วงหน้า การใช้ hook เพื่อ grep ผลการทดสอบให้เหลือเฉพาะรายการที่ล้มเหลวก่อนที่ Claude จะเห็น จะช่วยเปลี่ยนผลลัพธ์จากเครื่องมือขนาด 20,000 token ให้เหลือเพียง 300 token และจะช่วยประหยัดได้ทุกครั้งที่มีการส่งข้อมูลนั้นซ้ำในอนาคต
• ประมวลผลแบบ batch สำหรับงานที่ไม่ต้องโต้ตอบ สำหรับ API pipeline ของคุณเอง ไม่ว่าจะเป็นการจำแนกประเภท, การตรวจสอบจำนวนมาก หรือ job ที่รันตอนกลางคืน Batches API จะรันโมเดลเดียวกันในราคาลด 50% โดยแลกกับการส่งผลลัพธ์แบบไม่เรียลไทม์ (asynchronous)
• คำนึงถึงเวลาของ cache ทำงานอย่างต่อเนื่องในคราวเดียว Claude Code session ใน tmux บน VPS จะไม่มีค่าใช้จ่ายขณะที่ไม่ได้ใช้งาน โดยจะเสียค่า token เฉพาะเมื่อมีการรันคำสั่งเท่านั้น แต่เวลาที่ปล่อยทิ้งไว้จะทำให้ cache ที่อุ่นอยู่สูญเสียไป และการรันครั้งถัดไปจะต้องเสียค่าใช้จ่ายในการเขียนข้อมูลใหม่ทั้งหมด

FAQ

การเขียนโค้ดหนึ่งเซสชันใน Claude Code ใช้โทเค็นจำนวนเท่าใด

ไม่มีจำนวนที่ตายตัว โดยทั่วไปการโต้ตอบหนึ่งครั้งในช่วงกลางเซสชันอาจมี prompt tokens หลายหมื่นโทเค็นเมื่อมีการสะสมไฟล์และประวัติการสนทนา และเซสชันการทำงานหนึ่งอาจใช้โทเค็นรวมถึงหลายล้านโทเค็น ซึ่งส่วนใหญ่จะถูกเรียกใช้จากแคชในอัตราหนึ่งในสิบของราคาปกติ สำหรับการประเมินเบื้องต้น ข้อมูลองค์กรที่ Anthropic เผยแพร่ ณ เดือนกรกฎาคม 2026 ระบุค่าใช้จ่ายเฉลี่ยอยู่ที่ประมาณ $13 ต่อนักพัฒนาต่อวันที่มีการใช้งาน โดยผู้ใช้ 90% มีค่าใช้จ่ายไม่เกิน $30 ให้ลองรัน /usage ในเซสชันของคุณเอง การสังเกตการใช้งานจริงสักห้านาทีนั้นให้ข้อมูลที่แม่นยำกว่าค่าเฉลี่ยที่เผยแพร่ทั่วไป

thinking tokens มีค่าใช้จ่ายหรือไม่แม้ว่าจะมองไม่เห็นในหน้าจอ

มีค่าใช้จ่าย โดย thinking tokens จะถูกคิดเงินในอัตราเดียวกับ output tokens ซึ่งเป็นอัตราที่สูงกว่า และถูกนับรวมใน max_tokens นอกจากนี้โมเดลปัจจุบันยังคิดค่าใช้จ่ายดังกล่าวแม้ว่าอินเทอร์เฟซจะไม่ได้แสดงสรุปกระบวนการคิดให้เห็นก็ตาม หากการตอบกลับถูกตัดจบด้วย stop_reason: "max_tokens" ก่อนที่คำตอบที่มองเห็นได้จะเสร็จสมบูรณ์ แสดงว่ากระบวนการคิดอาจใช้โควตาจนหมด ใน Claude Code คุณสามารถลดระดับความพยายามด้วย /effort สำหรับงานที่ไม่จำเป็นต้องใช้การคิดวิเคราะห์เชิงลึก

ทำไมเซสชันการใช้งาน Claude Code ที่ยาวนานขึ้นจึงมีค่าใช้จ่ายต่อข้อความสูงขึ้น

เนื่องจาก API เป็นแบบ stateless: ทุกการโต้ตอบจะส่งประวัติการสนทนาทั้งหมด ไฟล์ที่อ่าน ผลลัพธ์จากเครื่องมือ และการแลกเปลี่ยนข้อมูลก่อนหน้ากลับไปใหม่ทั้งหมดในฐานะ input ที่ต้องเสียค่าใช้จ่าย ดังนั้นการโต้ตอบครั้งที่ 50 จึงต้องแบกรับข้อมูลจากการโต้ตอบครั้งที่ 1 ถึง 49 ไปด้วย ระบบ prompt caching จะช่วยประมวลผลส่วนนำที่ซ้ำกันในราคาประมาณหนึ่งในสิบของราคา input ปกติ แต่ส่วนนำนั้นจะขยายใหญ่ขึ้นเรื่อยๆ และหากมีการเว้นช่วงการใช้งานนานเกินกว่าค่า TTL ของแคช การโต้ตอบครั้งถัดไปจะถูกคิดราคาเต็มเสมือนการส่งใหม่ทั้งหมด /compact จะช่วยลดขนาดประวัติการสนทนา และ /clear จะเป็นการรีเซ็ตประวัติใหม่

ฉันจะตรวจสอบการใช้งานโทเค็นและค่าใช้จ่ายของ Claude ได้อย่างไร

ใน Claude Code คำสั่ง /usage จะแสดงสถิติโทเค็นของเซสชัน การประเมินค่าใช้จ่ายเบื้องต้น และแถบแสดงขีดจำกัดของแผนการใช้งาน (/cost เป็นคำสั่งย่อ) ส่วน /context จะแสดงข้อมูลที่กำลังใช้พื้นที่ใน context window สำหรับข้อมูลการเรียกเก็บเงินอย่างเป็นทางการจาก API ให้ตรวจสอบที่หน้า usage ใน Claude Console สำหรับการตรวจสอบในโค้ดของคุณเอง ให้ดูที่ response.usage โดยการรวมค่า input_tokens, cache_creation_input_tokens และ cache_read_input_tokens จะได้ขนาดของ prompt ที่แท้จริง และคุณสามารถประเมินล่วงหน้าได้ด้วย endpoint count_tokens โดยห้ามใช้ tiktoken ในการประเมิน