บทนำ: เมื่อระบบราคาล่มสลายเพราะคำนวณผิด
ในช่วงปลายปี 2024 ทีมพัฒนา AI SaaS ของผมเผชิญกับปัญหาครั้งใหญ่ — ระบบสมัครสมาชิกที่ออกแบบมาอย่างดีกลับสร้างความสูญเสียมากกว่า 40% ต่อเดือน เนื่องจากคำนวณต้นทุน token ผิดพลาด สถานการณ์เริ่มต้นเมื่อลูกค้ารายใหญ่รายหนึ่งใช้งาน API และได้รับใบแจ้งหนี้ที่ต่ำกว่าต้นทุนจริงถึง 70% ทำให้บริษัทต้องแบกรับค่าใช้จ่ายเอง
บทเรียนจากเหตุการณ์นี้ทำให้ผมตระหนักว่า การกำหนดราคาสำหรับ AI SaaS ไม่ใช่แค่การตั้งตัวเลขแล้วคูณด้วย margin ธุรกิจ มันต้องอาศัยความเข้าใจลึกซึ้งในโครงสร้างต้นทุน พฤติกรรมผู้ใช้ และกลไกการ scaling ของโมเดล AI
ในบทความนี้ ผมจะแบ่งปันแนวทางการออกแบบ pricing strategy ที่ทดสอบแล้วว่าใช้ได้จริง พร้อมโค้ดตัวอย่างสำหรับ implement ระบบคำนวณราคาอัตโนมัติ
1. ทำความเข้าใจโครงสร้างต้นทุนของ AI API
ก่อนจะกำหนดราคาได้ ต้องเข้าใจต้นทุนที่แท้จริงก่อน AI API มีต้นทุนหลักสองส่วน:
Input Token — ค่าใช้จ่ายสำหรับข้อความที่ส่งเข้าโมเดล ซึ่งคิดตามจำนวน token ของ prompt
Output Token — ค่าใช้จ่ายสำหรับข้อความที่โมเดลตอบกลับ ซึ่งมักมีราคาสูงกว่า input เนื่องจากใช้ compute มากกว่าในการ generate
ต้นทุนต่อล้าน token (MTok) จาก
สมัครที่นี่ ในปี 2026:
ต้นทุนต่อล้าน token (MTok) - อัปเดต 2026
PRICING_MATRIX = {
"gpt-4.1": {
"input": 8.00, # $8/MTok input
"output": 24.00, # $24/MTok output
"description": "โมเดลระดับสูงสุด สำหรับงานซับซ้อน"
},
"claude-sonnet-4.5": {
"input": 15.00,
"output": 45.00,
"description": "เหมาะกับงานเขียนและวิเคราะห์"
},
"gemini-2.5-flash": {
"input": 2.50,
"output": 7.50,
"description": "ต้นทุนต่ำ เหมาะกับงานทั่วไป"
},
"deepseek-v3.2": {
"input": 0.42,
"output": 1.26,
"description": "ต้นทุนต่ำสุด ประหยัด 85%+ เมื่อเทียบกับ OpenAI"
}
}
อัตราแลกเปลี่ยน
USD_TO_CNY = 7.2 # ประมาณการ
CNY_TO_THB = 4.8 # ประมาณการ
2. การคำนวณต้นทุนต่อ request
เมื่อเข้าใจโครงสร้างราคาแล้ว ขั้นตอนถัดไปคือการสร้างฟังก์ชันคำนวณต้นทุนที่แม่นยำ ฟังก์ชันนี้จะใช้ในการ track ค่าใช้จ่ายจริงของลูกค้าแต่ละราย
import tiktoken
from dataclasses import dataclass
from typing import Optional
@dataclass
class TokenCost:
model: str
input_tokens: int
output_tokens: int
total_cost_usd: float
total_cost_thb: float
def count_tokens(text: str, model: str) -> int:
"""
นับจำนวน token สำหรับข้อความที่กำหนด
ใช้ tiktoken สำหรับโมเดลของ OpenAI-compatible APIs
"""
try:
encoding = tiktoken.encoding_for_model("gpt-4")
except KeyError:
encoding = tiktoken.get_encoding("cl100k_base")
return len(encoding.encode(text))
def calculate_request_cost(
model: str,
prompt: str,
response: str,
pricing: dict,
markup_percentage: float = 50.0
) -> TokenCost:
"""
คำนวณต้นทุนและราคาขายสำหรับ request หนึ่งครั้ง
Args:
model: ชื่อโมเดล (เช่น 'deepseek-v3.2')
prompt: ข้อความที่ส่งเข้าไป
response: ข้อความที่ได้รับตอบกลับ
pricing: dict ของราคา input/output ต่อ MTok
markup_percentage: % markup ที่ต้องการ (default 50%)
Returns:
TokenCost object พร้อมข้อมูลค่าใช้จ่ายทั้งหมด
"""
# นับ token
input_tokens = count_tokens(prompt, model)
output_tokens = count_tokens(response, model)
# คำนวณต้นทุน (แปลงเป็น USD ก่อน)
mtok_input = input_tokens / 1_000_000
mtok_output = output_tokens / 1_000_000
input_cost = mtok_input * pricing[model]["input"]
output_cost = mtok_output * pricing[model]["output"]
total_cost_usd = input_cost + output_cost
# เพิ่ม markup
selling_price_usd = total_cost_usd * (1 + markup_percentage / 100)
# แปลงเป็น THB
cost_thb = total_cost_usd * USD_TO_CNY * CNY_TO_THB
selling_thb = selling_price_usd * USD_TO_CNY * CNY_TO_THB
return TokenCost(
model=model,
input_tokens=input_tokens,
output_tokens=output_tokens,
total_cost_usd=round(cost_thb, 4),
total_cost_thb=round(selling_thb, 4)
)
ตัวอย่างการใช้งาน
prompt = "อธิบายหลักการทำงานของ AI SaaS pricing strategy"
response = "AI SaaS pricing strategy คือกลยุทธ์การกำหนดราคาที่คำนึงถึงต้นทุน token..."
cost = calculate_request_cost(
model="deepseek-v3.2",
prompt=prompt,
response=response,
pricing=PRICING_MATRIX,
markup_percentage=50.0
)
print(f"โมเดล: {cost.model}")
print(f"Input tokens: {cost.input_tokens}")
print(f"Output tokens: {cost.output_tokens}")
print(f"ต้นทุน: ฿{cost.total_cost_usd:.4f}")
print(f"ราคาขาย (50% markup): ฿{cost.total_cost_thb:.4f}")
3. การออกแบบโครงสร้างแพ็กเกจ
หลังจากเข้าใจต้นทุนต่อ request แล้ว ต้องออกแบบโครงสร้างแพ็กเกจที่ตอบสนองความต้องการของลูกค้าหลายกลุ่ม กลยุทธ์ที่ได้ผลดีคือ tiered pricing ที่มี 3-4 ระดับ
from enum import Enum
from typing import List, Dict, Optional
class PlanTier(Enum):
STARTER = "starter"
PROFESSIONAL = "professional"
ENTERPRISE = "enterprise"
CUSTOM = "custom"
@dataclass
class PricingPlan:
tier: PlanTier
name_th: str
monthly_price_thb: float
monthly_token_limit: int
features: List[str]
support_level: str
overage_rate_per_mtok: float # ค่าบริการเกิน limit ต่อ MTok (THB)
โครงสร้างแพ็กเกจที่แนะนำ
PRICING_PLANS = [
PricingPlan(
tier=PlanTier.STARTER,
name_th="เริ่มต้น",
monthly_price_thb=999,
monthly_token_limit=10_000_000, # 10 MTok
features=[
"เข้าถึง DeepSeek V3.2 (ราคาประหยัด 85%+)",
"เข้าถึง Gemini 2.5 Flash",
"Dashboard พื้นฐาน",
"Support ผ่าน Email"
],
support_level="email",
overage_rate_per_mtok=3.0
),
PricingPlan(
tier=PlanTier.PROFESSIONAL,
name_th="มืออาชีพ",
monthly_price_thb=4999,
monthly_token_limit=100_000_000, # 100 MTok
features=[
"เข้าถึงทุกโมเดล (DeepSeek, Gemini, GPT-4.1, Claude)",
"เข้าถึง API ล่วงหน้า (Early Access)",
"Dashboard ขั้นสูง + Analytics",
"Priority Support",
"Custom webhooks"
],
support_level="priority",
overage_rate_per_mtok=2.5
),
PricingPlan(
tier=PlanTier.ENTERPRISE,
name_th="องค์กร",
monthly_price_thb=29999,
monthly_token_limit=1_000_000_000, # 1000 MTok
features=[
"ทุกอย่างใน Professional",
"Dedicated account manager",
"SLA 99.9% uptime",
"Custom rate limits",
"On-premise deployment option",
"SSO/Enterprise authentication"
],
support_level="dedicated",
overage_rate_per_mtok=2.0
)
]
def calculate_monthly_bill(
plan: PricingPlan,
actual_tokens_used: int,
model_distribution: Dict[str, float] # เปอร์เซ็นต์การใช้แต่ละโมเดล
) -> Dict:
"""
คำนวณค่าใช้จ่ายรายเดือนรวม
พิจารณา:
- ค่าบริการรายเดือน (fixed)
- ค่าบริการส่วนเกิน (ถ้าใช้เกิน limit)
"""
base_price = plan.monthly_price_thb
tokens_over = max(0, actual_tokens_used - plan.monthly_token_limit)
# คำนวณค่าใช้จ่ายส่วนเกินตาม model distribution
overage_cost = 0
if tokens_over > 0:
for model, percentage in model_distribution.items():
model_tokens = int(tokens_over * percentage)
mtok = model_tokens / 1_000_000
model_cost = mtok * PRICING_MATRIX[model]["input"] * USD_TO_CNY * CNY_TO_THB
overage_cost += model_cost * (1 + plan.overage_rate_per_mtok / 100)
total = base_price + overage_cost
return {
"plan": plan.name_th,
"base_price": base_price,
"tokens_used": actual_tokens_used,
"tokens_over_limit": tokens_over,
"overage_cost": round(overage_cost, 2),
"total_bill": round(total, 2),
"currency": "THB"
}
ตัวอย่างการคำนวณ
enterprise_plan = PRICING_PLANS[2]
actual_usage = 1_500_000_000 # 1500 MTok
model_mix = {
"deepseek-v3.2": 0.6,
"gemini-2.5-flash": 0.3,
"gpt-4.1": 0.1
}
bill = calculate_monthly_bill(enterprise_plan, actual_usage, model_mix)
print(f"แพ็กเกจ: {bill['plan']}")
print(f"ค่าบริการพื้นฐาน: ฿{bill['base_price']:,}")
print(f"ใช้งานเกิน: {bill['tokens_over_limit']:,} tokens")
print(f"ค่าบริการส่วนเกิน: ฿{bill['overage_cost']:,.2f}")
print(f"ยอดรวม: ฿{bill['total_bill']:,.2f}")
4. การ implement ระบบ API สำหรับ AI SaaS
ต่อไปคือการสร้าง API endpoint สำหรับจัดการ request และคำนวณค่าใช้จ่ายแบบ real-time โดยใช้ HolySheep AI API ซึ่งให้ความเร็วตอบสนองน้อยกว่า 50ms
import asyncio
import aiohttp
from datetime import datetime
from typing import Dict, List
import json
คอนฟิกการเชื่อมต่อ HolySheep API
BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY" # เปลี่ยนเป็น API key จริง
class AIUsageTracker:
"""ติดตามการใช้งานและคำนวณค่าใช้จ่ายแบบ real-time"""
def __init__(self):
self.session: Optional[aiohttp.ClientSession] = None
self.usage_records: List[Dict] = []
async def initialize(self):
"""เปิด connection pool"""
self.session = aiohttp.ClientSession(
headers={
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
},
timeout=aiohttp.ClientTimeout(total=30)
)
async def close(self):
"""ปิด connection"""
if self.session:
await self.session.close()
async def chat_completion(
self,
model: str,
messages: List[Dict],
user_id: str,
plan: PricingPlan
) -> Dict:
"""
ส่ง request ไปยัง AI และ track ค่าใช้จ่าย
"""
payload = {
"model": model,
"messages": messages,
"temperature": 0.7,
"max_tokens": 4096
}
start_time = datetime.now()
try:
async with self.session.post(
f"{BASE_URL}/chat/completions",
json=payload
) as response:
if response.status != 200:
error_text = await response.text()
raise Exception(f"API Error {response.status}: {error_text}")
result = await response.json()
# คำนวณค่าใช้จ่าย
usage = result.get("usage", {})
prompt_tokens = usage.get("prompt_tokens", 0)
completion_tokens = usage.get("completion_tokens", 0)
cost = calculate_request_cost(
model=model,
prompt=str(messages),
response=result.get("choices", [{}])[0].get("message", {}).get("content", ""),
pricing=PRICING_MATRIX,
markup_percentage=50.0
)
# บันทึก usage
record = {
"timestamp": start_time.isoformat(),
"user_id": user_id,
"plan": plan.name_th,
"model": model,
"prompt_tokens": prompt_tokens,
"completion_tokens": completion_tokens,
"cost_usd": cost.total_cost_usd,
"cost_thb": cost.total_cost_thb,
"latency_ms": (datetime.now() - start_time).total_seconds() * 1000,
"response": result
}
self.usage_records.append(record)
return {
"success": True,
"data": result,
"usage": record
}
except aiohttp.ClientError as e:
raise Exception(f"Connection error: {str(e)}")
def get_monthly_summary(self, user_id: str) -> Dict:
"""สรุปการใช้งานรายเดือน"""
user_records = [r for r in self.usage_records if r["user_id"] == user_id]
total_tokens = sum(r["prompt_tokens"] + r["completion_tokens"] for r in user_records)
total_cost_thb = sum(r["cost_thb"] for r in user_records)
return {
"user_id": user_id,
"total_requests": len(user_records),
"total_tokens": total_tokens,
"total_cost_thb": round(total_cost_thb, 4),
"avg_latency_ms": sum(r["latency_ms"] for r in user_records) / len(user_records) if user_records else 0
}
ตัวอย่างการใช้งาน
async def main():
tracker = AIUsageTracker()
try:
await tracker.initialize()
# ทดสอบ API call
result = await tracker.chat_completion(
model="deepseek-v3.2",
messages=[
{"role": "system", "content": "คุณเป็นผู้เชี่ยวชาญด้านการกำหนดราคา"},
{"role": "user", "content": "แนะนำกลยุทธ์ pricing สำหรับ AI SaaS startup"}
],
user_id="user_001",
plan=PRICING_PLANS[1] # Professional plan
)
print("ผลลัพธ์:")
print(json.dumps(result["usage"], indent=2, ensure_ascii=False))
# ดูสรุปรายเดือน
summary = tracker.get_monthly_summary("user_001")
print(f"\nสรุปรายเดือน: ฿{summary['total_cost_thb']:.2f}")
finally:
await tracker.close()
รัน async function
asyncio.run(main())
5. กลยุทธ์การ pricing ตาม value-based pricing
นอกจาก cost-plus pricing แล้ว ยังมีอีกแนวทางหนึ่งที่มีประสิทธิภาพสูง เรียกว่า value-based pricing ซึ่งกำหนดราคาตามมูลค่าที่ลูกค้าได้รับ ไม่ใช่ต้นทุนที่เราจ่าย
from typing import Callable, Dict, List
import math
@dataclass
class UseCase:
"""กรณีการใช้งานของลูกค้า"""
name: str
value_per_task_thb: float # มูลค่าที่ลูกค้าได้รับต่อ task
tasks_per_month: int # จำนวน task ที่คาดว่าจะใช้ต่อเดือน
avg_tokens_per_task: int # token เฉลี่ยต่อ task
def calculate_value_based_price(
use_cases: List[UseCase],
target_margin: float = 0.4 # 40% margin
) -> Dict:
"""
คำนวณราคาตามมูลค่าที่ลูกค้าได้รับ
หลักการ: ถ้าลูกค้าได้มูลค่า 100 บาท เราควรเก็บไม่เกิน 60 บาท (60% ของมูลค่า)
เพื่อให้ลูกค้ายังได้ ROI ที่ดี
"""
total_monthly_value = sum(
uc.value_per_task_thb * uc.tasks_per_month
for uc in use_cases
)
# คำนวณ token ที่ใช้ต่อเดือน
total_tokens_per_month = sum(
uc.avg_tokens_per_task * uc.tasks_per_month
for uc in use_cases
)
mtok_per_month = total_tokens_per_month / 1_000_000
# คำนวณต้นทุน (ใช้ DeepSeek V3.2 ซึ่งประหยัดที่สุด)
avg_cost_per_mtok = (PRICING_MATRIX["deepseek-v3.2"]["input"] * 0.3 +
PRICING_MATRIX["deepseek-v3.2"]["output"] * 0.7)
total_cost_thb = mtok_per_month * avg_cost_per_mtok * USD_TO_CNY * CNY_TO_THB
# ราคาที่แนะนำ (40% margin)
recommended_price = total_cost_thb / (1 - target_margin)
# ราคาที่ปัดเศษ (น่าจะเป็น tier ที่ใกล้เคียง)
rounded_price = math.ceil(recommended_price / 100) * 100
return {
"use_cases": [uc.name for uc in use_cases],
"total_monthly_value_thb": round(total_monthly_value, 2),
"total_tokens_per_month": total_tokens_per_month,
"cost_thb": round(total_cost_thb, 2),
"recommended_price_thb": round(recommended_price, 2),
"rounded_price_thb": rounded_price,
"roi_for_customer": round((total_monthly_value / rounded_price - 1) * 100, 1),
"margin": round((1 - total_cost_thb / rounded_price) * 100, 1)
}
ตัวอย่าง: บริษัท E-commerce ใช้ AI สำหรับ 3 กรณี
ecommerce_use_cases = [
UseCase(
name="Product description generation",
value_per_task_thb=50,
tasks_per_month=5000,
avg_tokens_per_task=200
),
UseCase(
name="Customer support automation",
value_per_task_thb=30,
tasks_per_month=15000,
avg_tokens_per_task=150
),
UseCase(
name="Review analysis",
value_per_task_thb=100,
tasks_per_month=2000,
avg_tokens_per_task=300
)
]
result = calculate_value_based_price(ecommerce_use_cases)
print(f"มูลค่ารวมที่ลูกค้าได้รับ: ฿{result['total_monthly_value_thb']:,}")
print(f"ต้นทุนของเรา: ฿{result['cost_thb']:,.2f}")
print(f"ราคาที่แนะนำ: ฿{result['recommended_price_thb']:,.2f}")
print(f"ราคาที่ปัดเศษ: ฿{result['rounded_price_thb']:,}")
print(f"ROI ของลูกค้า: {result['roi_for_customer']}%")
print(f"Margin ของเรา: {result['margin']}%")
ข้อผิดพลาดที่พบบ่อยและวิธีแก้ไข
1. ไม่ track usage ต่อ user — ส่งผลให้ margin ติดลบ
❌ วิธีที่ผิด: ไม่มีการ track per-user
async def bad_example():
async with session.post(f"{BASE_URL}/chat/completions", json=payload) as resp:
return await resp.json()
✅ วิธีที่ถูก: track usage per user
async def good_example():
async with session.post(f"{BASE_URL}/chat/completions", json=payload) as resp:
result = await resp.json()
usage = result.get("usage", {})
# บันทึกลง database ทุก request
await db.usage_logs.insert({
"user_id": current_user.id,
"model": model,
"prompt_tokens": usage.get("prompt_tokens", 0),
"completion_tokens": usage.get("completion_tokens", 0),
"timestamp": datetime.utcnow()
})
return result
2. ใช้ token encoding ผิดโมเดล — ทำให้คำนวณค่าใช้จ่ายผิด
❌ วิธีที่ผิด: hardcode encoding
def bad_token_count(text):
encoding = tiktoken.get_encoding("cl100k_base") # ใช้ได้กับ GPT-4 เท่านั้น
return len(encoding.encode(text))
✅ วิธีที่ถูก: map encoding ตามโมเดล
def good_token_count(text: str, model: str) -> int:
"""นับ token ตามโมเดลที่ใช้จริง"""
encoding_map = {
"gpt-4": "cl100k_base",
"gpt-3.5-turbo": "cl100k_base",
"claude-3": "cl100k_base", # Claude ก็ใช้ same encoding
"deepseek-v3.2": "cl100k_base",
"gemini-2.5-flash": "cl100k_base",
}
encoding_name = encoding_map.get(model, "cl100k_base")
encoding = tiktoken.get_encoding(encoding_name)
return len(encoding.encode(text))
3. ไม่ implement rate limiting — ทำให้โดน brute-force attack
❌ วิธีที่ผิด: ไม่มี rate limit
แหล่งข้อมูลที่เกี่ยวข้อง
บทความที่เกี่ยวข้อง