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

Token ใน Claude คืออะไร

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

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

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

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

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

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

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

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

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

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

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

โทเค็นขาออก (Output tokens) คือส่วนที่มีค่าใช้จ่ายสูง โดยมีราคาสูงกว่าโทเค็นขาเข้าถึง 5 เท่าในกลุ่มผลิตภัณฑ์ปัจจุบัน (ข้อมูล ณ เดือนกรกฎาคม 2026: Opus 4.8 อยู่ที่ $5/$25, Sonnet 5 อยู่ที่ $3/$15 และ Haiku 4.5 อยู่ที่ $1/$5) ผลลัพธ์นี้รวมถึงข้อความและโค้ดที่ Claude สร้างขึ้น และ โทเค็นการคิด (thinking tokens) ซึ่งเป็นกระบวนการใช้เหตุผลภายในที่โมเดลทำก่อนจะตอบคำถาม มีข้อเท็จจริง 2 ประการที่ต้องทราบในส่วนนี้: การคิดจะถูกเรียกเก็บเงินในอัตราขาออกและนับรวมอยู่ใน 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 การส่งข้อความครั้งเดียวหลังจากแคชหมดอายุจะมีราคาแพงกว่าการส่งข้อความแบบแคชยังทำงานอยู่ถึงกว่า 12 ครั้ง นี่คือผลลัพธ์ที่ขัดกับความรู้สึกซึ่งควรทำความเข้าใจไว้: จังหวะการทำงานแบบหยุดพักแล้วกลับมาทำใหม่ อาจมีราคาแพงกว่าการทำงานอย่างต่อเนื่อง เพราะทุกช่วงเวลาที่ว่างเว้นเกินกว่าค่า 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 token และ $25 ต่อล้าน output token สำหรับการโต้ตอบกลางเซสชันที่มีบริบทสะสม 80,000 token: โดยเป็นข้อมูลที่อ่านจาก cache 75,000 token, ข้อมูลที่เขียนลง cache ใหม่ 3,000 token, input ใหม่ที่ไม่ได้ cache 2,000 token และ output 1,500 token (รวมกระบวนการคิด)

• การอ่านจาก 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 token จะถูกเขียนใหม่ในราคา $6.25/M คิดเป็น $0.50 ก่อนรวมค่า output ซึ่งสูงกว่าการโต้ตอบแบบมี cache ถึงห้าเท่าสำหรับงานเดียวกัน ช่องว่างของราคานี้คือหัวใจสำคัญของการทำ caching ทั้งหมด บรรทัดคำนวณสี่บรรทัดนี้เป็นวิธีเดียวที่ตรงไปตรงมาในการเปรียบเทียบผู้ให้บริการ เพราะราคาหน้าเว็บไม่ได้รวมค่าอ่าน cache และค่ากระบวนการคิดไว้เลย และเมื่อนำไปทดสอบกับงานจริงสามงาน จะเห็นได้ว่า ค่าใช้จ่ายของ Claude สูงหรือต่ำกว่า OpenAI อย่างไร

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

การดูการใช้งานของคุณ

ใน Claude Code คำสั่งคือ /usage (/cost ยังคงใช้งานได้ โดยเป็นคำสั่งแทน) ส่วน Session ที่ด้านบนสุดจะแสดงสถิติโทเค็นและการประมาณค่าใช้จ่ายที่คำนวณในเครื่องสำหรับเซสชันปัจจุบัน สำหรับแผนการสมัครสมาชิก หน้าจอเดียวกันจะแสดงแถบขีดจำกัดของแผนและรายละเอียดการใช้งานที่แบ่งตามทักษะ, subagents, plugins และ MCP servers แต่ละตัว สำหรับข้อมูลการเรียกเก็บเงินที่ถูกต้องสำหรับบัญชี API หน้าการใช้งานใน Claude Console คือแหล่งข้อมูลที่เชื่อถือได้ ส่วนตัวเลขใน CLI เป็นเพียงการประมาณการเท่านั้น /context จะแสดงตารางสีของ สิ่งที่กำลังใช้พื้นที่ใน context window, system prompt, เครื่องมือ, คำนิยาม MCP, ไฟล์, ประวัติ และเป็นวิธีที่เร็วที่สุดในการตรวจหา CLAUDE.md ที่มีขนาดใหญ่เกินไปหรือ MCP server ที่มีการโต้ตอบมากเกินไป ให้ใส่ all เพื่อขยายดูรายละเอียดทั้งหมดของแต่ละรายการ

จาก API ทุกการตอบกลับจะบอกคุณอย่างชัดเจนว่าเกิดอะไรขึ้น:

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}")

โปรดทราบว่า input_tokens เป็นเพียง ส่วนที่เหลือที่ไม่ได้แคชไว้ เท่านั้น ขนาดของ prompt ที่แท้จริงคือผลรวมของช่อง input ทั้งสามช่อง เอเจนต์ที่ทำงานเป็นเวลาหนึ่งชั่วโมงโดยแสดง input_tokens: 4000 ไม่ได้หมายความว่ามีราคาถูก เพราะโทเค็นอีก 200,000 ตัวถูกดึงมาจากแคช หากต้องการประมาณการก่อนส่ง ให้ใช้ endpoint สำหรับนับโทเค็น ซึ่งสามารถเรียกใช้งานได้ฟรี มีขีดจำกัดอัตรา (rate limit) แยกต่างหาก และนับด้วย tokenizer ของโมเดลที่คุณระบุ (ให้ถือว่าผลลัพธ์เป็นการประมาณการที่ใกล้เคียง ส่วนการเรียกเก็บเงินจะอ้างอิงตามคำขอจริง):

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

ห้ามใช้ tiktoken ด้วยเหตุผลข้างต้น

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

กลไกการทำงานในคู่มือนี้เหมือนกันทุกประการ ต่างกันเพียงวิธีการชำระเงินเท่านั้น หากใช้ 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 จะไม่ช่วยให้กลับมาใช้งานได้ เนื่องจากหน้าต่างเวลาเหล่านี้ใช้ร่วมกันทุกโมเดล หน้าต่างเวลาเหล่านี้ผูกกับบัญชีผู้ใช้ไม่ใช่ตัว client ที่คุณกำลังใช้งานอยู่ ซึ่งเป็นเรื่องที่ควรทราบหากคุณกำลังศึกษาว่า สิ่งใดทำงานแบบ native บน Linux และแผนใดครอบคลุมการใช้งานในส่วนใดบ้าง การทราบว่าคุณใช้งานหน้าต่างเวลาใดจนครบจะเป็นตัวกำหนดระยะเวลารอคอยและสิ่งที่คุณควรทำในระหว่างนั้น ดังนั้นจึงควรทราบ ทางเลือกของคุณเมื่อถึงขีดจำกัดระหว่างทำงาน แผนการใช้งานสามารถเปิดใช้งานเครดิตเพิ่มเติมได้ ซึ่งจัดการผ่าน /usage-credits เพื่อซื้อสิทธิ์การใช้งานเกินเพดานที่กำหนดไว้ ผมจงใจไม่ระบุโควตาของแต่ละแผนไว้ เนื่องจากเป็นตัวเลขที่มีการเปลี่ยนแปลงบ่อยที่สุดในหัวข้อนี้ ดังนั้นโปรดตรวจสอบที่ claude.com/pricing และแถบ /usage ของคุณเอง กลไกของ token ยังคงมีความสำคัญแม้ในการสมัครสมาชิก เพราะเซสชันที่สิ้นเปลืองจะเผาผลาญโควตาหน้าต่างเวลาของคุณในลักษณะเดียวกับการเผาผลาญเงินจริง สำหรับรายละเอียดด้านการสมัครสมาชิก โปรดดู แผน Claude ใดที่เหมาะสมกับการใช้งานของคุณ

กลไกที่ใช้งานได้จริง

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

FAQ

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

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

โทเค็นสำหรับการคิด (thinking tokens) มีค่าใช้จ่ายหรือไม่แม้ว่าจะมองไม่เห็น

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

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

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

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

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