DEV Community: Thanawat Wongchai

วิธีใช้ DeepSeek V4 ฟรี

Thanawat Wongchai — Fri, 24 Apr 2026 05:32:53 +0000

DeepSeek V4 เปิดตัวเมื่อวันที่ 23 เมษายน 2026 และแตกต่างจากเทคโนโลยีชั้นนำส่วนใหญ่ เพราะช่องทางฟรีใช้งานได้จริง แชทบนเว็บอย่างเป็นทางการใช้ V4-Pro โดยไม่ต้องใช้บัตรเครดิต น้ำหนักโมเดลเป็นแบบ MIT-licensed และดาวน์โหลดได้ทันที ผู้รวมบริการอย่าง OpenRouter และ Chutes มักจะเปิดใช้งานฟรีไม่กี่วันหลังโมเดลออก คุณสามารถใช้งาน V4 ในงานจริงได้โดยไม่มีค่าใช้จ่าย ก่อนจะตัดสินใจเติมเงินเข้าบัญชีด้วยซ้ำ

ทดลองใช้ Apidog วันนี้

คู่มือนี้สรุปทุกเส้นทางฟรีที่ยืนยันได้ พร้อมคำแนะนำว่าควรเลือกเส้นทางไหนในแต่ละกรณี และวิธีตั้งค่าคอลเล็กชันที่พร้อมใช้งานจริงใน Apidog เพื่อให้การเปลี่ยนไปใช้แบบจ่ายเงินราบรื่นเมื่อใช้งานเพิ่มขึ้น

สำหรับภาพรวมระดับผลิตภัณฑ์ ดูที่ DeepSeek V4 คืออะไร สำหรับคู่มือ API อย่างละเอียด ดูที่ วิธีการใช้ DeepSeek V4 API

TL;DR (สรุปสั้นๆ)

chat.deepseek.com — แชทบนเว็บฟรีบน V4-Pro, สลับโหมด Think High/Max ได้, ไม่ต้องใช้บัตรเครดิต
โฮสต์โมเดล Hugging Face + GPU ของตัวเอง — MIT license, V4-Flash รันบน H100 2-4 ใบ, V4-Pro ต้องการคลัสเตอร์ใหญ่
OpenRouter และ Chutes — เกตเวย์บุคคลที่สาม, มีโควต้าฟรีสำหรับ DeepSeek ภายในสัปดาห์แรก
Hugging Face Inference Providers — ปลายทางใช้งานร่วมกัน, มี rate limit ใช้ทดลองเบื้องต้นได้
เครดิตทดลอง Kaggle, Colab, RunPod — GPU ฟรีสำหรับรันครั้งเดียว, เหมาะกับการทดสอบ self-hosting
ทุกเส้นทางฟรีมีขีดจำกัด สำหรับงาน production ให้เปลี่ยนไปใช้แบบจ่ายเงินก่อนถึงลิมิต

เส้นทางที่ 1: chat.deepseek.com (เส้นทางฟรีเริ่มต้น)

เส้นทางฟรีที่เร็วและเสถียรที่สุดคือแชท UI อย่างเป็นทางการ V4-Pro เป็นโมเดลหลัก สวิตช์ด้านบนของกล่องข้อความใช้สลับ Non-Think, Think High, Think Max ได้

การตั้งค่า

ไปที่ chat.deepseek.com
ลงชื่อเข้าใช้ด้วย email, Google หรือ WeChat
ตรวจสอบว่าเลือกโมเดล V4-Pro
เริ่มใช้งานได้ทันที

สิ่งที่คุณจะได้รับ

บริบทยาว 1M โทเค็นเต็ม
อัปโหลด PDF, รูป, โค้ด ได้
ค้นหาเว็บในตัว
เลือก Reasoning mode ได้ทั้งสามแบบ
ประวัติแชทและโฟลเดอร์

ลักษณะของขีดจำกัด

ไม่มีระบุจำนวนข้อความสูงสุดต่อวัน บริการฟรีจะถูก rate-limit แบบนุ่มนวลเมื่อโหลดสูง การใช้งานหนักอาจตอบช้า/จัดคิว แต่แทบไม่เคยบล็อกถาวร หากเจอ rate limit บ่อย ควรลดความถี่หรือเปลี่ยนไปใช้ API

งานเหมาะสม: ทดสอบพรอมต์ยาก, ตรวจสอบ repo, รัน Think Max กับไฟล์ยาวๆ งานไม่เหมาะ: ระบบอัตโนมัติ/การรันซ้ำจำนวนมาก

เส้นทางที่ 2: โฮสต์ V4-Flash ด้วยตัวเองบน GPU ของคุณ

V4-Flash เป็นโมเดล MIT-license ที่โฮสต์เองได้จริง ขนาด 284B (13B ที่ active) H100 สองใบรัน FP8 ได้ การ quantize INT4 ใส่บน H100 80GB ใบเดียวได้

ค่าใช้จ่ายคือฮาร์ดแวร์ ไม่ใช่ license ถ้ามี GPU ว่าง นี่คือทางฟรีที่เสถียรสุด เพราะไม่โดน limit หรือปิดบริการได้

ดึงน้ำหนักโมเดล

pip install -U "huggingface_hub[cli]"
huggingface-cli login
huggingface-cli download deepseek-ai/DeepSeek-V4-Flash \
  --local-dir ./models/deepseek-v4-flash

น้ำหนัก ~500GB (FP8) เตรียม disk ให้พอ

ให้บริการด้วย vLLM

pip install "vllm>=0.9.0"

vllm serve deepseek-ai/DeepSeek-V4-Flash \
  --tensor-parallel-size 4 \
  --max-model-len 1048576 \
  --dtype auto \
  --port 8000

เปิดใช้งานแล้ว ชี้ไคลเอนต์ที่รองรับ OpenAI API ไปที่ http://localhost:8000/v1 ใช้รูปแบบเดียวกับ DeepSeek API แบบจ่ายเงิน Apidog รองรับ URL นี้ได้ คอลเล็กชันเดิมใช้ต่อได้เลย

ตรวจสอบความเป็นจริงของฮาร์ดแวร์

รุ่น	การ์ดขั้นต่ำ (FP8)	การ์ดขั้นต่ำ (INT4)	Throughput
V4-Flash	2 × H100 80GB	1 × H100 80GB	50-150 โทเค็น/วินาที
V4-Pro	16 × H100 80GB	8 × H100 80GB	ขึ้นกับคลัสเตอร์

ถ้าไม่มี GPU ว่าง การเช่า GPU มักจะแพ้ API แบบจ่ายเงิน เหมาะสำหรับทีมที่มีเครื่องเองหรือมีข้อบังคับที่ต้องโฮสต์เอง

เส้นทางที่ 3: OpenRouter บริการฟรี

OpenRouter คือเกตเวย์รวมโมเดล open/closed ไว้ใน API เดียว แพลตฟอร์มมักเปิดบริการฟรีสำหรับ DeepSeek ทุกรุ่น (V3-V4 ก็เช่นกัน)

การตั้งค่า

สมัคร openrouter.ai
สร้าง API Key
ดูแคตตาล็อก deepseek/deepseek-v4-pro หรือ deepseek/deepseek-v4-flash รุ่นฟรีจะมี :free ต่อท้าย
เรียกใช้งานด้วย SDK ที่รองรับ OpenAI

from openai import OpenAI

client = OpenAI(
    api_key=OPENROUTER_KEY,
    base_url="https://openrouter.ai/api/v1",
)

response = client.chat.completions.create(
    model="deepseek/deepseek-v4-flash:free",
    messages=[{"role": "user", "content": "Write a Python CLI for semver bumping."}],
)

print(response.choices[0].message.content)

ขีดจำกัด

OpenRouter ฟรีจำกัดร้อยกว่าคำขอต่อวันต่อคีย์ ลด priority เมื่อโหลดสูง เหมาะกับการ prototyping ไม่เหมาะกับ production

เส้นทางที่ 4: Hugging Face Inference Providers

Hugging Face เปิด Inference endpoint ให้ใช้ V4 checkpoint ได้หลังเปิดตัว มี rate limit และ latency ผันผวน แต่ใช้ฟรี

from huggingface_hub import InferenceClient

client = InferenceClient(model="deepseek-ai/DeepSeek-V4-Flash")

response = client.chat_completion(
    messages=[{"role": "user", "content": "Summarize the V4 technical report in 5 bullets."}],
    max_tokens=512,
)

print(response.choices[0].message.content)

HF Token ฟรี ถ้าใช้งานหนักค่อยอัปเกรด Pro (rate limit ผ่อนคลาย ค่าใช้จ่ายน้อยกว่า API official)

เส้นทางที่ 5: เครดิตทดลองบน Colab, Kaggle, RunPod และ Lambda

ผู้ให้บริการ GPU ส่วนใหญ่มีเครดิตทดลอง ใช้อย่างเหมาะสมสามารถทดลอง V4-Flash ฟรีได้

Google Colab: ฟรี T4 เล็กไป, Colab Pro+ ได้ 500 compute units/เดือน ใช้ A100 ทดลอง V4-Flash ได้
Kaggle: GPU ฟรีรายสัปดาห์ (T4/P100) เล็กไปสำหรับ V4-Pro, เพียงพอสำหรับ V4-Flash แบบ quantized บางครั้ง
RunPod: เครดิตทดลอง $10 ใช้ H100 ได้ 2-3 ชม. เปิด vLLM, รัน benchmark แล้วปิดเครื่อง
Lambda: โปรฟรี H100/H200 เป็นครั้งคราว เช็คหน้าสมัคร

ทั้งหมดนี้เหมาะสำหรับเทสต์จบในครั้งเดียว ไม่ใช่ทางฟรีระยะยาว

สร้างคอลเล็กชัน Apidog ที่ไม่ขึ้นกับผู้ให้บริการ

ข้อดีของเส้นทางฟรีหลายแบบ คือสามารถทดสอบพรอมต์เดียวกันกับทุก backend ได้โดยไม่ต้องแก้ไขซ้ำ ขั้นตอน:

ดาวน์โหลด Apidog
สร้างคอลเล็กชันเดียว มี 4 environment: chat (placeholder), deepseek (https://api.deepseek.com/v1), openrouter (https://openrouter.ai/api/v1), self-hosted (http://localhost:8000/v1)
บันทึก request POST ไปที่ {{BASE_URL}}/chat/completions
ตั้งค่าคีย์แต่ละผู้ให้บริการเป็น secret variable เนื้อหา request เดียวกันหมด
สลับ environment เพื่อ A/B test พรอมต์เดียวกันทุก backend

รูปแบบเดียวกับ คอลเล็กชัน GPT-5.5 ฟรี; เครื่องมือเดียว ทุก backend ไม่ต้อง config ซ้ำ

คุณควรเลือกเส้นทางฟรีเส้นทางไหน?

ต้องการ feedback ภายใน 5 นาที — ใช้ chat.deepseek.com
สร้าง prototype — ใช้ OpenRouter ฟรีจนหมดโควต้า จากนั้นเติมเงิน DeepSeek
มี GPU และต้องการ compliance — โฮสต์ V4-Flash เองบน vLLM
ต้องการใช้ฟรีระยะยาว — ไม่มีทางฟรี 100% ทุกบริการฟรีมีลิมิต ใช้ chat.deepseek.com สำหรับงาน interactive เติมเงินเล็กน้อยสำหรับ automation

เมื่อไหร่ที่ควรย้ายออกจากบริการฟรี

ถูก rate-limit เกินวันละ 1 ครั้ง — แปลว่ามีภาระงานมากพอควรมีงบแล้ว
ต้องการ SLA — ฟรีไม่มี SLA, API จ่ายเงินมี
ต้องการ log, monitoring หรือ compliance — API จ่ายเงินมี billing log ชัดเจน, ฟรีไม่มี

ถึงจุดนี้ ให้ย้ายไป API อย่างเป็นทางการ เติมเงินขั้นต่ำ $2 ราคาต่อโทเค็นต่ำสุดในกลุ่ม enterprise

คำถามที่พบบ่อย

chat.deepseek.com ฟรีจริงหรือ? ใช่ ไม่ต้องใช้บัตรเครดิต ไม่มี trial timer บริการนี้ soft-limit แต่ไม่ต้องจ่ายเงิน

ต้องมีบัญชี Hugging Face เพื่อดาวน์โหลดน้ำหนักโมเดลไหม? ทางเทคนิคไม่จำเป็น (repo สาธารณะ) แต่ในทางปฏิบัติจำเป็น เพราะช่วยให้ rate-limit สูงขึ้น

เส้นทางฟรีไหนรัน V4-Pro จริง? chat.deepseek.com รัน V4-Pro เต็ม บริการ OpenRouter ฟรีมักจะเป็น V4-Flash ถ้าต้องการ V4-Pro ฟรี ใช้เว็บแชทดีที่สุด

นำบริการฟรีไปใช้กับ production ได้ไหม? ไม่ควร! ฟรีมี rate limit, ข้อกำหนดเปลี่ยนบ่อย, อาจปิดตัวตอนไหนก็ได้ ถ้าให้บริการลูกค้า ใช้ API แบบจ่ายเงินหรือโฮสต์เอง

โฮสต์เองฟรีจริงไหม? License ฟรี แต่ฮาร์ดแวร์ไม่ฟรี ถ้ามี GPU ว่าง ค่าใช้จ่ายคือค่าไฟ ถ้าเช่า GPU มักแพ้ API แบบจ่ายเงิน

Apidog มีบริการฟรีให้ทดสอบไหม? Apidog ฟรีสำหรับออกแบบ/ทดสอบ API คิดเงินเมื่อใช้ API จ่ายเงินผ่าน Apidog ดังนั้น ใช้ workspace Apidog ฟรีกับ chat.deepseek.com หรือ OpenRouter ได้ ขั้นตอนการทำงานฟรี 100%

วิธีรัน DeepSeek V4 ในเครื่องตัวเอง

Thanawat Wongchai — Fri, 24 Apr 2026 04:59:23 +0000

DeepSeek V4 เปิดตัวเมื่อวันที่ 23 เมษายน 2026 พร้อมน้ำหนักโมเดลแบบ MIT License บน Hugging Face การเลือกใช้ใบอนุญาตเดียวนี้เปลี่ยนโอกาสสำหรับทุกทีมที่ต้องการ AI ระดับแนวหน้าบนฮาร์ดแวร์ของตัวเอง V4-Flash (284 พันล้านพารามิเตอร์, 13 พันล้านพารามิเตอร์ที่ทำงานอยู่) สามารถรันบน H100 สองตัว (FP8) หรือการ์ดเดียว (INT4) V4-Pro (1.6 ล้านล้านพารามิเตอร์, 49 พันล้านพารามิเตอร์ที่ทำงานอยู่) ต้องการคลัสเตอร์ แต่ประสิทธิภาพเทียบชั้น GPT-5.5 และ Claude Opus 4.6 ในงานโค้ดและ reasoning

ลองใช้ Apidog วันนี้

คู่มือนี้สรุปขั้นตอนติดตั้งใช้งาน DeepSeek V4 แบบ local-deployment: ข้อกำหนดฮาร์ดแวร์, ควอนไทซ์, vLLM/SGLang, การตั้งค่าและทดสอบกับ Apidog ก่อนนำไปใช้งานจริง

สำหรับภาพรวมผลิตภัณฑ์ ดู DeepSeek V4 คืออะไร วิธีใช้งาน API แบบโฮสต์ ดู วิธีใช้ DeepSeek V4 API เปรียบเทียบต้นทุน ดู ราคา DeepSeek V4 API

สรุปโดยย่อ

V4-Flash: ทำงานบน 2 × H100 80GB (FP8) หรือ 1 × H100 (INT4); น้ำหนักโมเดล ~500GB (FP8)
V4-Pro: ต้องการ H100 16 ตัวขึ้นไป (FP8) สำหรับ production workload
vLLM: วิธีที่เร็วที่สุดในการตั้งเซิร์ฟเวอร์ที่เข้ากันได้กับ OpenAI (vllm>=0.9.0 รองรับ V4)
SGLang: สำหรับงานที่ต้องใช้การเรียกฟังก์ชัน/structured output
ควอนไทซ์: ใช้ AWQ INT4 หรือ GPTQ INT4 เพื่อรัน V4-Flash บนการ์ด 80GB เดียว (คุณภาพ drop ~5%)
ใช้ Apidog ชี้ไปที่ http://localhost:8000/v1 ใช้คอลเลกชันเดิมจาก Hosted API ได้ทันที

ใครควรโฮสต์ด้วยตัวเอง

การโฮสต์ V4 ด้วยตัวเองเหมาะกับทีมเหล่านี้:

ข้อจำกัดด้าน compliance: งานสุขภาพ, การเงิน, กฎหมาย, รัฐ ที่ข้อมูลห้ามออกนอกระบบ MIT License ลดข้อจำกัดด้าน legal/data residency
workload ขนาดใหญ่เสถียร: ถ้าใช้งานระดับ 200B+ โทเค็น/เดือน self-host คุ้มกว่าจ่าย per-token
Fine-tuning/วิจัย: เช็คพอยต์ Base พร้อมสำหรับต่อยอด, MIT License รองรับ commercial derivative

ไม่ควรโฮสต์เอง: ทีม prototype, ไม่มีประสบการณ์ GPU, หรือ workload ต่ำกว่า 200 USD/เดือน – ค่า infra จะสูงกว่าที่ประหยัดได้

ข้อกำหนดด้านฮาร์ดแวร์

DeepSeek V4 ใช้ FP4+FP8 native precision ประหยัดหน่วยความจำ:

รูปแบบ	พารามิเตอร์ทั้งหมด	พารามิเตอร์ที่ทำงาน	VRAM (FP8)	VRAM (INT4)	การ์ดขั้นต่ำ
V4-Flash	284B	13B	~500GB	~140GB	2 × H100 80GB (FP8) / 1 × H100 (INT4)
V4-Pro	1.6T	49B	~2.4TB	~700GB	16 × H100 80GB (FP8) / 8 × H100 (INT4)

หมายเหตุ

ต้องมี VRAM สำหรับ MoE "ทุก expert" ไม่ใช่แค่ active
H200, MI300X ใช้แทน H100 ได้ (VRAM per card สูงกว่า)
GPU consumer (RTX 5090) ไม่พอ แม้แต่ V4-Flash INT4
Apple Silicon (M3/M4 Max 128GB) รันได้แต่ช้ามาก เหมาะ dev/test เท่านั้น

ขั้นตอนที่ 1: ดาวน์โหลดน้ำหนักโมเดล

แหล่งอย่างเป็นทางการ:

deepseek-ai/DeepSeek-V4-Flash
deepseek-ai/DeepSeek-V4-Pro
deepseek-ai/DeepSeek-V4-Flash-Base, DeepSeek-V4-Pro-Base สำหรับ Fine-tuning

ติดตั้ง CLI และดาวน์โหลด:

pip install -U "huggingface_hub[cli]"
huggingface-cli login

huggingface-cli download deepseek-ai/DeepSeek-V4-Flash \
  --local-dir ./models/deepseek-v4-flash \
  --local-dir-use-symlinks False

สำรอง disk ~500GB (V4-Flash) หรือหลายเทรา (V4-Pro)
สำหรับ users จีน: modelscope.cn โหลดเร็วขึ้น

ขั้นตอนที่ 2: เลือกเอนจินสำหรับให้บริการ

เลือก 1 ใน 2:

vLLM: throughput สูงสุด, compatible กับ OpenAI, community ใหญ่
SGLang: ฟีเจอร์ tool-calling, structured output, long context

ทั้งสองรองรับ DeepSeek V4 (อัพเดทล่าสุด)

ขั้นตอนที่ 3: ให้บริการ V4-Flash ด้วย vLLM

pip install "vllm>=0.9.0"

vllm serve deepseek-ai/DeepSeek-V4-Flash \
  --tensor-parallel-size 2 \
  --max-model-len 1048576 \
  --dtype auto \
  --enable-prefix-caching \
  --port 8000

แฟล็กหลัก:

--tensor-parallel-size: จำนวน H100 ที่ใช้
--max-model-len: context window (1M โทเค็น, ลดเหลือ 131072 เพื่อประหยัด VRAM)
--enable-prefix-caching: cache prompt prefix
--dtype auto: รองรับ FP8 mix

เซิร์ฟเวอร์พร้อมใช้งานผ่าน OpenAI-compatible client ที่ http://localhost:8000/v1

ขั้นตอนที่ 4: ให้บริการ V4-Pro ด้วย vLLM

V4-Pro ต้องการคลัสเตอร์ (multi-node):

vllm serve deepseek-ai/DeepSeek-V4-Pro \
  --tensor-parallel-size 8 \
  --pipeline-parallel-size 2 \
  --max-model-len 524288 \
  --enable-prefix-caching \
  --port 8000

context 512K โทเค็น (เพิ่มได้ถ้า VRAM เหลือ)
pipeline/tensor parallelism สำหรับ multi-node

ขั้นตอนที่ 5: ให้บริการด้วย SGLang (tool-calling)

pip install "sglang[all]>=0.4.0"

python -m sglang.launch_server \
  --model-path deepseek-ai/DeepSeek-V4-Flash \
  --tp 2 \
  --context-length 1048576 \
  --port 30000

endpoint ที่ http://localhost:30000/v1
DSL lang ของ SGLang เหมาะสำหรับ function call/json mode

ขั้นตอนที่ 6: ควอนไทซ์สำหรับการ์ด GPU เดียว

INT4 quantization ทำให้รันบน H100 (80GB) เดียวได้

AWQ (แนะนำ)

pip install autoawq

python -c "
from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

model_path = './models/deepseek-v4-flash'
out_path = './models/deepseek-v4-flash-awq'
model = AutoAWQForCausalLM.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.quantize(tokenizer, quant_config={'w_bit': 4, 'q_group_size': 128})
model.save_quantized(out_path)
tokenizer.save_pretrained(out_path)
"

GPTQ

pip install auto-gptq
# ทำตาม pattern คล้าย AWQ

ให้บริการโมเดลควอนไทซ์ผ่าน vLLM:

เพิ่ม --quantization awq หรือ --quantization gptq ตอนรัน vLLM

ขั้นตอนที่ 7: ทดสอบด้วย Apidog

อย่าส่ง traffic production ก่อนทดสอบ server ภายใน

ดาวน์โหลด Apidog
สร้าง collection ชี้ที่ http://localhost:8000/v1/chat/completions
วาง prompt test เดียวกับ Hosted API, เปรียบเทียบผล side-by-side
ทดสอบ context 500K token เพื่อตรวจสอบ KV Cache
ทดสอบ flow tool-calling end-to-end ก่อนเชื่อมต่อ agent loop

Collection เดิมที่ใช้กับ DeepSeek V4 API แบบโฮสต์ ใช้กับ local server ได้ทันที เปลี่ยน base-url อย่างเดียว

การตรวจสอบและการเฝ้าระวัง

ติดตาม 4 metric นี้ตั้งแต่เริ่ม:

โทเค็นต่อวินาที: vLLM มี Prometheus /metrics
GPU Utilization: ใช้ nvidia-smi หรือ DCGM ถ้าต่ำกว่า 70% ปรับ batch size
KV Cache Hit Rate: เปิด --enable-prefix-caching แล้วดูอัตรา cache hit
Request latency (p50/p95/p99): trace มาตรฐาน; p99 สูงแปลว่าบาง request pattern ทำให้คิวช้า

ส่ง metric เหล่านี้ไป Grafana หรือ observability ที่ใช้งานอยู่

การ Fine-tuning เช็คพอยต์ V4 Base

Base checkpoint สำหรับ pretrain/sft:

pip install "torch>=2.6" transformers accelerate peft trl

# ตัวอย่าง SFT + LoRA
python -m trl sft \
  --model_name_or_path deepseek-ai/DeepSeek-V4-Flash-Base \
  --dataset_name your-org/your-sft-set \
  --output_dir ./models/v4-flash-custom \
  --per_device_train_batch_size 1 \
  --gradient_accumulation_steps 16 \
  --learning_rate 2e-5 \
  --bf16 true \
  --use_peft true \
  --lora_r 64 \
  --lora_alpha 128

Full-parameter finetune บน V4-Pro = งานวิจัยหนัก
LoRA adapters บน V4-Flash-Base = practical สำหรับทีมส่วนใหญ่

ข้อผิดพลาดที่พบบ่อย

OOM ตอน start: --max-model-len สูงเกิน/--tensor-parallel-size ต่ำเกิน แก้โดยลด context หรือเพิ่ม parallelism
Request แรกช้า: vLLM lazy kernel compile; warmup ด้วย dummy request
tool-call parsing error: DeepSeek encoding ไม่เหมือน OpenAI 100% ใช้ SDK ที่รองรับ V4 โดยตรง
FP8 error บนการ์ดเก่า: A100 ไม่รองรับ FP8 ใช้ BF16 แทน (VRAM เพิ่ม 2x)

เมื่อไหร่ควร self-host

อ้างอิง ราคา DeepSeek V4 แบบโฮสต์:

V4-Flash: 200B input + 20B output token/เดือน: Hosted API ~$33,600, เช่า 8 × H100 ~$20,000 (ประหยัด ~40%)
V4-Pro: 500B input + 50B output/เดือน: Hosted API ~$1.04M, คลัสเตอร์ 16 × H100 ~$35,000 (ประหยัด 95%+)

จุดคุ้มทุน V4-Flash ~100B token/เดือน ต่ำกว่านี้ Hosted API ถูกกว่า

คำถามที่พบบ่อย

V4-Flash รันบน A100 เดียวได้ไหม? ได้ (INT4+context สั้น), แต่ throughput 5-15 tps, H100 เหมาะกว่า
V4 รองรับ LoRA finetune? รองรับ ใช้ checkpoint base + TRL/Axolotl workflow
Local server compatible กับ OpenAI ไหม? ใช่ ทั้ง vLLM/SGLang เปิด /v1/chat/completions และ /v1/completions format เดียวกับ OpenAI (คู่มือ Hosted API)
เปิด Thinking Mode ยังไง? ส่ง thinking_mode: "thinking" หรือ "thinking_max" ใน body
สตรีมจาก local V4 server ได้ไหม? ได้ ส่ง stream: true
ทดลองก่อนซื้อ hardware ทำยังไงถูกสุด? เช่า H100 บน RunPod/Lambda ชั่วคราว รัน V4-Flash INT4 วัด throughput จริง

วิธีใช้ DeepSeek V4 API

Thanawat Wongchai — Fri, 24 Apr 2026 04:29:47 +0000

DeepSeek V4 เปิดตัวพร้อม API ที่ใช้งานได้ทันทีในวันแรก รหัสโมเดลคือ deepseek-v4-pro และ deepseek-v4-flash ซึ่งเป็นปลายทางที่เข้ากันได้กับ OpenAI และ URL หลักคือ https://api.deepseek.com นั่นหมายความว่าไคลเอนต์ใดๆ ที่คุณใช้อยู่แล้วกับ GPT-5.5 หรือ API รูปแบบ OpenAI อื่นๆ สามารถทำงานร่วมกับ V4 ได้ด้วยการเปลี่ยน URL หลักเพียงครั้งเดียว

ทดลองใช้ Apidog วันนี้

คู่มือนี้ครอบคลุมการยืนยันตัวตน, พารามิเตอร์สำคัญทุกตัว, ตัวอย่าง Python และ Node, การคำนวณในโหมดคิด (thinking-mode math), การเรียกใช้เครื่องมือ (tool calling), การสตรีม, และเวิร์กโฟลว์ที่ใช้ Apidog ซึ่งจะช่วยให้คุณเห็นค่าใช้จ่ายขณะที่คุณวนซ้ำการทำงาน

สำหรับภาพรวมระดับผลิตภัณฑ์ โปรดดู DeepSeek V4 คืออะไร สำหรับวิธีใช้งานแบบไม่มีค่าใช้จ่าย โปรดดู วิธีใช้ DeepSeek V4 ฟรี

สรุปโดยย่อ

DeepSeek V4 มาพร้อมปลายทางที่เข้ากันได้กับ OpenAI ที่ https://api.deepseek.com/v1/chat/completions และปลายทางที่เข้ากันได้กับ Anthropic ที่ https://api.deepseek.com/anthropic
รหัสโมเดล: deepseek-v4-pro (รวม 1.6T, ใช้งาน 49B) และ deepseek-v4-flash (รวม 284B, ใช้งาน 13B)
ทั้งสองรุ่นรองรับบริบท 1M โทเค็น และสามโหมดการคิด: non-thinking, thinking, thinking_max
ใช้ temperature=1.0, top_p=1.0 ตามที่ DeepSeek แนะนำ; อย่าใช้ค่าเริ่มต้นของ GPT-5.5 หรือ Claude
รหัสเก่า deepseek-chat และ deepseek-reasoner จะเลิกใช้งานในวันที่ 24 กรกฎาคม 2026; ควรย้ายข้อมูลก่อนหน้านั้น
ดาวน์โหลด Apidog เพื่อเล่นคำขอซ้ำ, เปรียบเทียบโหมดการคิด, และป้องกันไม่ให้คีย์ของคุณอยู่ในประวัติเชลล์

ข้อกำหนดเบื้องต้น

เตรียมสิ่งเหล่านี้ก่อนเริ่มใช้งาน:

บัญชีนักพัฒนา DeepSeek ที่ platform.deepseek.com โดยมียอดเงินอย่างน้อย 2 ดอลลาร์ หากไม่มียอดเงิน การเรียกใช้งานจะส่งคืน 402 Insufficient Balance
คีย์ API ที่กำหนดขอบเขตสำหรับโครงการที่คุณจะเรียกเก็บเงิน คีย์ที่กำหนดขอบเขตโครงการมีความปลอดภัยมากกว่าคีย์บัญชีสำหรับการใช้งาน Production
SDK ที่รองรับ OpenAI API base URL เช่น Python openai>=1.30.0 หรือ Node openai@4.x
API Client ที่สามารถเล่นคำขอซ้ำได้ (curl ใช้ได้กับการเรียกเพียงครั้งเดียว หลังจากนั้นให้ใช้ Apidog)

ส่งออกคีย์ API ของคุณเพียงครั้งเดียว:

export DEEPSEEK_API_KEY="sk-..."

ปลายทางและการยืนยันตัวตน

เลือกปลายทางตามรูปแบบที่ต้องการ:

POST https://api.deepseek.com/v1/chat/completions    # รูปแบบ OpenAI
POST https://api.deepseek.com/anthropic/v1/messages  # รูปแบบ Anthropic

ส่วนใหญ่ให้ใช้ OpenAI endpoint

การยืนยันตัวตน: ใส่ Bearer Token ใน header Authorization

curl https://api.deepseek.com/v1/chat/completions \
  -H "Authorization: Bearer $DEEPSEEK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-pro",
    "messages": [
      {"role": "user", "content": "Explain MoE routing in two sentences."}
    ]
  }'

การตอบกลับสำเร็จจะคืน JSON body ที่มี choices, usage, และ id สำหรับการติดตาม

พารามิเตอร์คำขอ

แต่ละฟิลด์ส่งผลต่อค่าใช้จ่ายหรือพฤติกรรม ดูตารางนี้สำหรับ deepseek-v4-pro และ deepseek-v4-flash

พารามิเตอร์	ประเภท	ค่า	หมายเหตุ
`model`	สตริง	`deepseek-v4-pro`, `deepseek-v4-flash`	จำเป็นต้องระบุ
`messages`	อาร์เรย์	คู่ role/content	จำเป็นต้องระบุ ใช้ Schema เดียวกันกับ OpenAI
`thinking_mode`	สตริง	`non-thinking`, `thinking`, `thinking_max`	ค่าเริ่มต้นคือ `non-thinking`
`temperature`	โฟลต	0 ถึง 2	DeepSeek แนะนำ 1.0
`top_p`	โฟลต	0 ถึง 1	DeepSeek แนะนำ 1.0
`max_tokens`	จำนวนเต็ม	1 ถึง 131,072	จำกัดความยาวเอาต์พุต
`stream`	บูลีน	true หรือ false	เปิดใช้งานการสตรีม SSE
`tools`	อาร์เรย์	ข้อมูลจำเพาะเครื่องมือ OpenAI	สำหรับการเรียกใช้ฟังก์ชัน
`tool_choice`	สตริงหรือวัตถุ	`auto`, `required`, `none` หรือเครื่องมือเฉพาะ	ควบคุมการใช้เครื่องมือ
`response_format`	วัตถุ	`{"type": "json_object"}`	เอาต์พุตในโหมด JSON
`seed`	จำนวนเต็ม	จำนวนเต็มใดๆ	สำหรับความสามารถในการทำซ้ำ
`presence_penalty`	โฟลต	-2 ถึง 2	ลงโทษหัวข้อที่ซ้ำกัน
`frequency_penalty`	โฟลต	-2 ถึง 2	ลงโทษโทเค็นที่ซ้ำกัน

thinking_mode มีผลโดยตรงกับค่าใช้จ่ายและคุณภาพ non-thinking เร็วสุด, thinking เพิ่มความแม่นยำแต่ใช้โทเค็นมากขึ้น, thinking_max เหมาะสำหรับความถูกต้องสูงสุด (ต้องการ context 384K+)

ไคลเอนต์ Python

ใช้ OpenAI SDK โดยเปลี่ยน base_url ได้ทันที ตัวอย่าง:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://api.deepseek.com/v1",
)

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[
        {"role": "system", "content": "Reply in code only."},
        {"role": "user", "content": "Write a Rust function that debounces events."},
    ],
    extra_body={"thinking_mode": "thinking"},
    temperature=1.0,
    top_p=1.0,
    max_tokens=2048,
)

choice = response.choices[0]
print("Content:", choice.message.content)
print("Reasoning tokens:", response.usage.reasoning_tokens)
print("Total tokens:", response.usage.total_tokens)

ส่ง thinking_mode ผ่าน extra_body เพื่อรองรับฟิลด์ DeepSeek โดยไม่ต้องแก้ไขไลบรารี

ไคลเอนต์ Node

Node SDK รองรับฟิลด์เพิ่มเติมทันที:

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.DEEPSEEK_API_KEY,
  baseURL: "https://api.deepseek.com/v1",
});

const response = await client.chat.completions.create({
  model: "deepseek-v4-flash",
  messages: [
    { role: "user", content: "Explain the Muon optimizer in plain English." },
  ],
  thinking_mode: "thinking",
  temperature: 1.0,
  top_p: 1.0,
});

console.log(response.choices[0].message.content);
console.log("Usage:", response.usage);

การสตรีมการตอบกลับ

เปิด stream: true แล้ววนลูปผลลัพธ์:

stream = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[{"role": "user", "content": "Stream a 300-word essay on MoE."}],
    stream=True,
    extra_body={"thinking_mode": "non-thinking"},
)

for chunk in stream:
    delta = chunk.choices[0].delta.content or ""
    print(delta, end="", flush=True)

ถ้าเปิดโหมดคิด delta.reasoning_content จะสตรีมเหตุผลแยก สามารถใช้หรือข้ามได้

การเรียกใช้เครื่องมือ

รองรับ Tool Calling ตาม Schema OpenAI ตัวอย่าง:

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Return the current weather for a city.",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string"},
                "unit": {"type": "string", "enum": ["c", "f"]},
            },
            "required": ["city"],
        },
    },
}]

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[{"role": "user", "content": "Weather in Lagos in Celsius?"}],
    tools=tools,
    tool_choice="auto",
    extra_body={"thinking_mode": "thinking"},
)

tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.function.name, tool_call.function.arguments)

หลังจากเรียกใช้ฟังก์ชัน เพิ่มผลลัพธ์เป็น role: "tool" แล้วเรียก API อีกรอบ วนลูปจนกว่าจะได้คำตอบสุดท้าย

โหมด JSON

ระบุ response_format={"type": "json_object"} เพื่อบังคับ JSON output:

response = client.chat.completions.create(
    model="deepseek-v4-flash",
    messages=[
        {"role": "system", "content": "Reply with a single JSON object."},
        {"role": "user", "content": "Summarize this release note as {title, date, bullets}: ..."},
    ],
    response_format={"type": "json_object"},
    extra_body={"thinking_mode": "non-thinking"},
)

ถ้าต้องการตรวจสอบ schema ฝั่งไคลเอนต์ แนะนำใช้ Pydantic หรือ Zod

สร้างคอลเลกชันใน Apidog

ลดความซ้ำซ้อนและควบคุมค่าใช้จ่ายด้วย Workflow ต่อไปนี้:

ดาวน์โหลด Apidog และสร้างโปรเจกต์
เพิ่ม Environment ที่กำหนด {{DEEPSEEK_API_KEY}} เป็นตัวแปรลับ
บันทึกคำขอ POST ไปยัง {{BASE_URL}}/chat/completions พร้อม header Authorization: Bearer {{DEEPSEEK_API_KEY}}
ปรับ model และ thinking_mode สำหรับ A/B Test รุ่นต่างๆ
ใช้ response viewer เพื่อตรวจสอบ usage.reasoning_tokens ทุกรัน จะช่วยจับการใช้โหมดคิดโดยไม่จำเป็น

หากใช้ คอลเลกชัน GPT-5.5 อยู่ใน Apidog อยู่แล้ว ให้สลับ base URL และรหัสโมเดล แล้วรันเปรียบเทียบได้ทันที

การจัดการข้อผิดพลาด

DeepSeek API ใช้รูปแบบ error response เดียวกับ OpenAI ตาราง error ทั่วไป:

รหัส	ความหมาย	วิธีแก้ไข
400	คำขอไม่ถูกต้อง	ตรวจสอบ Schema JSON โดยเฉพาะ `messages` และ `tools`
401	คีย์ไม่ถูกต้อง	สร้างใหม่ที่ platform.deepseek.com
402	ยอดเงินไม่เพียงพอ	เติมเงินในบัญชี
403	ไม่อนุญาตโมเดล	ตรวจสอบขอบเขตของคีย์และการสะกดรหัสโมเดล
422	พารามิเตอร์อยู่นอกช่วง	`max_tokens` หรือ `thinking_mode` อาจไม่ตรงกัน
429	เกินขีดจำกัดอัตรา	รอสักครู่แล้วลองใหม่ด้วย exponential jitter
500	ข้อผิดพลาดเซิร์ฟเวอร์	ลองใหม่หนึ่งครั้ง; หากซ้ำ ให้ตรวจสอบหน้าสถานะ
503	โอเวอร์โหลด	กลับไปใช้ V4-Flash หรือลองใหม่ใน 30 วินาที

ห่อโค้ดเรียก API ด้วยตัวช่วย retry ที่รองรับ 429/5xx แบบ exponential backoff หลีกเลี่ยง retry ทันทีหากเจอ 4xx

รูปแบบการควบคุมค่าใช้จ่าย

ใช้ V4-Flash เป็นค่าตั้งต้น สลับเป็น V4-Pro เฉพาะเมื่อคุณวัดแล้วคุณภาพจำเป็น
กำหนด thinking_max เป็น opt-in ใช้เฉพาะกรณีที่ต้องการความถูกต้องสูง
จำกัด max_tokens เอาต์พุต 2,000 โทเค็นเพียงพอสำหรับส่วนใหญ่
บันทึก usage ทุกครั้ง ส่งข้อมูลโทเค็นอินพุต/เอาต์พุต/เหตุผลเข้าระบบ monitor แจ้งเตือนเมื่อ usage พุ่ง

การย้ายข้อมูลจากโมเดล DeepSeek รุ่นเก่า

เปลี่ยนรหัสโมเดลจาก deepseek-chat หรือ deepseek-reasoner เป็น deepseek-v4-pro แล้วทดสอบการตอบกลับ ตัวอย่าง:

-  model="deepseek-chat"
+  model="deepseek-v4-pro"

แนะนำให้เปรียบเทียบ A/B ใน Apidog ก่อน deploy จริง เพื่อดูผลลัพธ์และปรับงบประมาณ

คำถามที่พบบ่อย

API ของ DeepSeek V4 พร้อมใช้งานในระดับ Production หรือไม่? พร้อมใช้งานทันที API เปิดให้บริการตั้งแต่ 23 เมษายน 2026

V4 รองรับรูปแบบข้อความของ Anthropic หรือไม่? รองรับ ส่งคำขอไป https://api.deepseek.com/anthropic/v1/messages

บริบท (context window) กว้างแค่ไหน? 1M โทเค็นทั้ง V4-Pro และ V4-Flash (thinking_max แนะนำ 384K ขึ้นไป)

จะนับโทเค็นอินพุตก่อนส่ง API ได้อย่างไร? ใช้ OpenAI tokenizer ประมาณค่า DeepSeek จะส่ง usage ที่แน่นอนกลับมา

Fine-tune ผ่าน API ได้หรือไม่? ยังไม่ได้ Fine-tune ปัจจุบันรองรับเฉพาะ base checkpoint บน Hugging Face

API มีให้ทดลองใช้ฟรีไหม? ไม่มีแพ็คเกจฟรี แต่ผู้สมัครใหม่อาจได้เครดิตทดลองใช้เป็นบางเวลา

ราคา DeepSeek V4 API

Thanawat Wongchai — Fri, 24 Apr 2026 04:29:18 +0000

DeepSeek ได้ประกาศราคา V4 ในวันเดียวกับที่เปิดตัวโมเดล (23 เมษายน 2026) โดยกำหนดมาตรฐานใหม่สำหรับ AI ระดับแนวหน้า V4-Flash มีราคา $0.14 ต่อ 1 ล้านโทเค็นนำเข้า และ $0.28 ต่อ 1 ล้านโทเค็นส่งออก ส่วน V4-Pro จะอยู่ที่ $1.74 สำหรับนำเข้า และ $3.48 สำหรับส่งออก ทั้งสองรุ่นมี context window ขนาด 1 ล้านโทเค็น และโทเค็นส่งออกสูงสุด 384K พร้อม cache-hit discount ที่ลดต้นทุนนำเข้าลง 80–90% สำหรับ prompt ที่ซ้ำกัน

ทดลองใช้ Apidog วันนี้

คู่มือนี้ครอบคลุมอัตราค่าบริการ วิธีที่ context caching มีผลต่อต้นทุนจริง การเปรียบเทียบกับ GPT-5.5 และ Claude Opus และ 4 วิธีควบคุมค่าใช้จ่ายให้คาดการณ์ได้ใน Apidog

สำหรับภาพรวมผลิตภัณฑ์ ดู DeepSeek V4 คืออะไร สำหรับคู่มือ dev ดู วิธีใช้ DeepSeek V4 API สำหรับวิธีใช้ฟรี ดู วิธีใช้ DeepSeek V4 ฟรี

สรุปโดยย่อ

V4-Flash: $0.14 / M สำหรับนำเข้า (ไม่พบในแคช), $0.028 / M สำหรับนำเข้า (พบในแคช), $0.28 / M สำหรับส่งออก
V4-Pro: $1.74 / M สำหรับนำเข้า (ไม่พบในแคช), $0.145 / M สำหรับนำเข้า (พบในแคช), $3.48 / M สำหรับส่งออก
Context window: นำเข้า 1M โทเค็น, ส่งออก 384K โทเค็น (ทั้งสองรุ่น)
Cache-hit discount: ประมาณลด 80% สำหรับ Flash, ลด 92% สำหรับ Pro กรณี prefix ซ้ำกัน
deepseek-chat และ deepseek-reasoner จะเลิกใช้วันที่ 24 กรกฎาคม 2026; การเรียกเก็บเงินอิง V4-Flash
ที่อัตรา cache-miss, V4-Pro ถูกกว่า GPT-5.5 ~2.9 เท่าสำหรับนำเข้า และ ~8.6 เท่าสำหรับส่งออก

ตารางอัตราค่าบริการทั้งหมด

โมเดล	นำเข้า (ไม่พบในแคช)	นำเข้า (พบในแคช)	ส่งออก	บริบท
`deepseek-v4-flash`	$0.14 / M	$0.028 / M	$0.28 / M	1M / 384K
`deepseek-v4-pro`	$1.74 / M	$0.145 / M	$3.48 / M	1M / 384K
`deepseek-chat` (จะเลิกใช้ 2026-07-24)	อ้างอิง V4-Flash (โหมดไม่คิด)	—	—	—
`deepseek-reasoner` (จะเลิกใช้ 2026-07-24)	อ้างอิง V4-Flash (โหมดคิด)	—	—	—

จุดสำคัญสำหรับการใช้งานจริง:

ราคาไม่เปลี่ยนตาม "โหมดคิด" หรือ "ไม่คิด" แต่ขึ้นกับ model ID โหมด reasoning มีผลต่อจำนวนโทเค็นที่ใช้งานเท่านั้น
Cache-hit pricing ทำงานอัตโนมัติ: ทุก request ที่ prefix ตรงกัน (>= 1024 โทเค็น, ตรงทุกไบต์) ใน account เดียวกันจะได้ราคาถูกลง ไม่ต้องตั้งค่าเพิ่ม
รหัส deepseek-chat/deepseek-reasoner รุ่นเก่า ถูกคิดเงินเป็น alias ของ V4-Flash แล้ว กำหนดเส้นตายเลิกใช้คือ 24 กรกฎาคม 2026

การแคชบริบท (Context Caching) อธิบายแบบใช้งาน

การแคชคือหัวใจของการควบคุมต้นทุน DeepSeek V4. ทุกอย่างที่ซ้ำในแต่ละ request (เช่น system prompt, agent tool schema, RAG context) จะถูกคิดราคาแบบ cache-hit อัตโนมัติในการเรียกซ้ำ

ตัวอย่าง:

เรียกใช้ agent ด้วย system prompt 20,000 โทเค็น ถาม user 100 ข้อ (200 โทเค็น/ข้อ)

แบบไม่มีแคช:

นำเข้า: 100 × 20,200 × $1.74 / M = $3.52
ส่งออก: 100 × 500 × $3.48 / M = $0.17
รวม: $3.69

แบบมีแคช (ครั้งแรกไม่เจอแคช, 99 ครั้งต่อไปเจอ):

นำเข้าครั้งแรก: 20,200 × $1.74 / M = $0.035
prefix ที่เจอแคช (99 ครั้ง): 99 × 20,000 × $0.145 / M = $0.287
ส่วน user ที่ไม่เจอแคช (99 ครั้ง): 99 × 200 × $1.74 / M = $0.034
ส่งออก: 100 × 500 × $3.48 / M = $0.174
รวม: $0.53

สรุป: ประหยัด ~7 เท่าสำหรับงานเหมือนกัน โดยเฉพาะถ้าใช้ V4-Flash จะถูกลงมาก

เปรียบเทียบกับ GPT-5.5 และ Claude

โมเดล	นำเข้า (มาตรฐาน)	นำเข้า (แคช)	ส่งออก	บริบท
DeepSeek V4-Flash	$0.14 / M	$0.028 / M	$0.28 / M	1M
DeepSeek V4-Pro	$1.74 / M	$0.145 / M	$3.48 / M	1M
GPT-5.5	$5 / M	$1.25 / M	$30 / M	1M
GPT-5.5 Pro	$30 / M	—	$180 / M	1M
Claude Opus 4.6	$15 / M	$1.50 / M	$75 / M	200K

สรุปการเปรียบเทียบ:

ส่งออก: V4-Pro ถูกกว่า GPT-5.5 ~8.6 เท่า, Claude Opus ~21 เท่า
นำเข้าที่แคช: V4-Pro ถูกกว่า GPT-5.5 ~10 เท่า และ Claude ~10 เท่า สำหรับ system prompt/schemas/RAG context ที่ซ้ำกัน
คุณภาพเทียบราคา: V4-Pro เทียบเท่า GPT-5.5 ใน LiveCodeBench และ Codeforces แต่ต้นทุนต่ำกว่ามาก (ดู ตารางเกณฑ์มาตรฐาน)

ข้อควรระวัง: Claude ดีกว่าใน long-context retrieval และ Gemini 3.1 Pro ยังนำหน้า MMLU-Pro สำหรับ use case ที่ต้องดึงข้อมูลขนาดใหญ่ อาจต้องเทียบคุณภาพก่อนเลือก

การสร้างแบบจำลองต้นทุนสำหรับปริมาณงานทั่วไป

1. Agentic coding loop (context 50K, output 2K, 20 calls/job)

นำเข้า: 50,000 × 20 × $1.74 / M = $1.74
ส่งออก: 2,000 × 20 × $3.48 / M = $0.14
ต้นทุนต่องาน: ~$1.88

เทียบ GPT-5.5 ≈ $6.20 ต่องาน

2. Long-document Q&A (context 500K, output 1K)

นำเข้า: 500,000 × $1.74 / M = $0.87
ส่งออก: 1,000 × $3.48 / M = $0.003
ต้นทุนต่อ call: ~$0.87

เทียบ GPT-5.5 ≈ $2.53 ต่อ call

3. High-volume classification (context 2K, output 200, 10,000 calls)

ใช้ V4-Flash จะคุ้มที่สุด

นำเข้า: 2,000 × 10,000 × $0.14 / M = $2.80
ส่งออก: 200 × 10,000 × $0.28 / M = $0.56
ต้นทุนรวม: ~$3.36

เทียบ GPT-5.5 ≈ $110

4. Repeated-prompt chatbot (system prompt 10K, user 500, output 1K, 1,000 sessions)

นำเข้าครั้งแรก: 10,500 × $1.74 / M = $0.018
นำเข้าที่แคช: 999 × 10,000 × $0.145 / M = $1.45
ส่วน user ที่ไม่แคช: 999 × 500 × $1.74 / M = $0.87
ส่งออก: 1,000 × 1,000 × $3.48 / M = $3.48
รวมต่อ 1,000 sessions: ~$5.82

เทียบ GPT-5.5 (มีแคช) ≈ $26.35

ค่าใช้จ่ายแอบแฝงที่ต้องระวัง

Token inflation ใน thinking mode: thinking_max ใช้โทเค็นส่งออกมากกว่า non-thinking 3–10 เท่า (ต่อ prompt เดียวกัน) กำหนดขีดจำกัดให้ดี
Context โตไม่รู้ตัว: Agent loop ที่ feed conversation ย้อนกลับทั้งก้อนจะโตเร็วมากใน context 1M token — limit หรือ summarize อย่างเข้มข้น
Retry storm: ถ้ามี retry ทุก 500 error จะเพิ่มต้นทุนหลายเท่า ให้ใช้ exponential backoff + limit retry ต่อ request
Cost volatility ระหว่าง dev: การ test ผ่าน curl จะ reload context ทุกครั้ง ใช้ Apidog แทน จะใกล้เคียง 0 เพราะเปลี่ยน variable ได้ ไม่ต้อง re-upload context ทุกครั้ง

ติดตามค่าใช้จ่ายใน Apidog

Workflow แนะนำสำหรับทีม dev:

ดาวน์โหลด Apidog แล้วตั้งค่า DEEPSEEK_API_KEY เป็น secret variable ในแต่ละ environment
สร้าง POST request ไปที่ https://api.deepseek.com/v1/chat/completions
ใน response panel ให้ pin ค่า usage.prompt_tokens, usage.completion_tokens, usage.reasoning_tokens ทุก call จะเห็นต้นทุนคำนวณพร้อมผลลัพธ์
กำหนด parameter model และ thinking_mode เพื่อ A/B test V4-Flash vs V4-Pro, Non-Think vs Think Max ได้ใน request เดียว
ทำซ้ำชุดข้อมูลเดียวกันกับ GPT-5.5 (ดูคู่มือ GPT-5.5 API) เทียบ cost side-by-side

ผล: ลดเซอร์ไพรส์ในบิลสิ้นเดือนได้ ~80%

สี่กฎที่ทำให้ค่าใช้จ่ายคาดการณ์ได้

ใช้ V4-Flash เป็น default เลือก V4-Pro เมื่อวัดคุณภาพแล้วว่าคุ้มกว่า
ใช้ Non-Think เป็น default เพิ่มเป็น Think High สำหรับงานยาก, ใช้ Think Max เฉพาะกรณีต้องแม่นยำสุด
จำกัด max_tokens 384K ควรเป็น safety limit ไม่ใช่เป้าหมาย การใช้งานจริง ส่วนใหญ่ใช้ ~2K
Log การใช้งาน บันทึก prompt_tokens, completion_tokens, reasoning_tokens ทุก call — แจ้งเตือนเมื่อ reasoning token พุ่งสูงผิดปกติ

คำถามที่พบบ่อย

มี free tier หรือไม่?

ไม่มี free API โดยตรง แต่บางครั้ง account ใหม่จะได้ trial credit เล็กน้อย สำหรับทางเลือกใช้ฟรีนอก API ดู วิธีใช้ DeepSeek V4 ฟรี

Cache-hit pricing ทำงานอย่างไร?

prefix (>=1024 tokens) ที่ซ้ำกันใน account เดียวกันจะได้ราคาถูกลงอัตโนมัติ

Request แรก: จ่าย rate ปกติ
Request ถัดไปที่ prefix ตรงกัน: จ่าย rate ลด ไม่ต้องตั้งค่าใดๆ

โหมด Think แพงกว่าหรือไม่?

อัตราต่อโทเค็นเท่ากัน แต่โหมดนี้ใช้ reasoning token มากกว่า ติดตามได้ใน usage.reasoning_tokens

ราคาคงที่หรือไม่?

DeepSeek มีการปรับราคาเป็นระยะ V3.2 คงที่ตลอดปี 2025, V4 ยังไม่ประกาศวันหมด ตรวจสอบ หน้าอัตราค่าบริการปัจจุบัน ก่อนตั้งงบ

V4-Pro กับ V4-Flash คิดค่าบริการส่งออกเท่ากันไหม?

ไม่เท่ากัน — V4-Pro $3.48 / M, V4-Flash $0.28 / M ต่างกัน 12.4 เท่า

Anthropic endpoint ส่งผลต่อราคาหรือไม่?

ไม่มีผล https://api.deepseek.com/anthropic ราคาเท่ากับ OpenAI endpoint ทุกรูปแบบ

วิธีใช้ DeepSeek V4 API ฟรี

Thanawat Wongchai — Fri, 24 Apr 2026 04:29:03 +0000

DeepSeek V4 เปิดตัวเมื่อวันที่ 23 เมษายน 2026 พร้อมราคา API ที่ถูกมากจนทีมส่วนใหญ่ไม่ต้องเสียเวลาหาบริการฟรี แต่สำหรับนักพัฒนาที่อยากทดลองหรือสร้างต้นแบบก่อนผูกบัตร ก็ยังมีวิธีใช้ฟรีอยู่ เช่น การใช้โมเดลผ่าน OpenRouter ตัวเลือก :free, เอนด์พอยต์ inference ของ Hugging Face, หรือเครดิตทดลองจาก DeepSeek เอง หากนำทั้งหมดมาเชื่อมสำรองใน Apidog ก็สามารถสร้างต้นแบบที่ขับเคลื่อนด้วย V4 โดยแทบไม่เสียค่าใช้จ่ายเลย

ทดลองใช้ Apidog วันนี้

คู่มือนี้เจาะจงที่เส้นทางฟรีของ API เท่านั้น สำหรับคู่มือเต็มที่รวมถึงการแชทและการโฮสต์ด้วยตัวเอง ดูที่ วิธีใช้ DeepSeek V4 ฟรี สำหรับคำอธิบายแบบละเอียดเกี่ยวกับบริการแบบชำระเงิน ดูที่ วิธีใช้ DeepSeek V4 API และสำหรับภาพรวมผลิตภัณฑ์ ดูที่ DeepSeek V4 คืออะไร

สรุป

OpenRouter ระดับฟรี — ใช้ deepseek/deepseek-v4-flash:free หรือบางครั้ง deepseek-v4-pro:free ได้ฟรี รองรับ OpenAI SDK เรียกใช้ได้หลายร้อยครั้งต่อวันต่อคีย์
Hugging Face Inference — ฟรี endpoint ที่ https://router.huggingface.co/hf-inference จำกัดอัตรา เหมาะกับการสร้างต้นแบบ
Chutes ระดับฟรี — เครือข่าย GPU ชุมชน มักจะเปิด DeepSeek endpoint ฟรีภายในสัปดาห์แรกหลังเปิดตัว
เครดิตทดลอง DeepSeek — สมัครใหม่บน platform.deepseek.com บางรอบจะมีเครดิตฟรีติดบัญชีมา
โฮสต์ V4-Flash เองบน GPU ของคุณก็ฟรี (เฉพาะค่าไลเซนส์) ดู วิธีรัน DeepSeek V4 บนเครื่องของคุณ
ใช้ Apidog ตั้งกลไก backup ให้เรียกแต่ละ provider ด้วยรูปแบบ request เดียวกัน

ทำไมเส้นทาง API ฟรีจึงมีอยู่

ถึง DeepSeek จะราคาต่ำที่สุดในวงการ แต่เส้นทางฟรีก็ยังจำเป็นใน 3 กรณีนี้

สร้างต้นแบบก่อนผูกบัตร — อยากลองเรียก API ในโค้ดก่อนผูกวิธีชำระเงิน เหมาะกับ PoC หรือข้อจำกัดการจัดซื้อ
งานนักเรียน/วิจัย/โอเพนซอร์ส — โปรเจกต์เล็ก ๆ ที่ไม่มีงบ ก็ต้องการคุณภาพระดับสูง
เปรียบเทียบคุณภาพ — ทดสอบ prompt เดียวกันกับ endpoint ฟรีหลายเจ้าจะเห็นความแตกต่าง latency/quality/uptime

ถ้าเป้าหมายคุณคือ production หรือปริมาณสูง แนะนำข้ามไปดู คู่มือ API แบบชำระเงิน การเติมเงิน $2 บน DeepSeek API ตรง ๆ จะประหยัดเวลากว่า

เส้นทางที่ 1: OpenRouter ระดับฟรี

OpenRouter คือ API gateway ที่รวมโมเดลชั้นนำไว้หลัง API เดียว รองรับ OpenAI SDK และมักจะเปิด :free ให้ใช้ฟรีในช่วงเปิดตัว DeepSeek

การตั้งค่า

สมัครที่ openrouter.ai
สร้าง API key ที่เมนู Settings → Keys
ดูแคตตาล็อกรุ่นที่ลงท้ายด้วย :free ปกติจะเป็น deepseek/deepseek-v4-flash:free
เรียก endpoint นี้ผ่าน OpenAI SDK

from openai import OpenAI

client = OpenAI(
    api_key=OPENROUTER_API_KEY,
    base_url="https://openrouter.ai/api/v1",
)

response = client.chat.completions.create(
    model="deepseek/deepseek-v4-flash:free",
    messages=[{"role": "user", "content": "Refactor this Go function to use channels."}],
)

print(response.choices[0].message.content)

ข้อจำกัด

คิว request ฟรีจะตามหลัง traffic ที่จ่ายเงิน
จำกัด ~50-200 requests/วัน/คีย์ และ parallel จำกัด
อาจถูกหยุดหรือจำกัดโดยไม่มีแจ้งล่วงหน้า
เหมาะกับ prototype ไม่ใช้ production

ตัวอย่าง Node.js

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.OPENROUTER_API_KEY,
  baseURL: "https://openrouter.ai/api/v1",
});

const response = await client.chat.completions.create({
  model: "deepseek/deepseek-v4-flash:free",
  messages: [{ role: "user", content: "Explain MoE routing like I'm 12." }],
});

console.log(response.choices[0].message.content);

เส้นทางที่ 2: ผู้ให้บริการอนุมานของ Hugging Face

Hugging Face เปิด endpoint inference ที่แชร์กันสำหรับ DeepSeek V4 หลังเปิดตัวไม่นาน ใช้ HF token (ฟรี) ได้ แต่อัตรา request จำกัดมาก

import os
from huggingface_hub import InferenceClient

client = InferenceClient(
    model="deepseek-ai/DeepSeek-V4-Flash",
    token=os.environ["HF_TOKEN"],
)

response = client.chat_completion(
    messages=[
        {"role": "user", "content": "Write a Python decorator that retries with jitter."}
    ],
    max_tokens=512,
)

print(response.choices[0].message.content)

รับ HF token ฟรีที่ huggingface.co/settings/tokens
Latency แตกต่างตามโหลด และ token quota จะรวมในงบรายวันของบัญชี
อัปเกรดเป็น HF Pro ลดข้อจำกัดโดยไม่ต้องใช้ DeepSeek API โดยตรง

เส้นทางที่ 3: Chutes และเกตเวย์ชุมชน

Chutes คือเครือข่าย GPU ที่โฮสต์โมเดล DeepSeek ฟรีหรือถูกมาก มี endpoint ที่รองรับ OpenAI SDK ที่ https://llm.chutes.ai/v1

client = OpenAI(
    api_key=CHUTES_API_KEY,
    base_url="https://llm.chutes.ai/v1",
)

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V4-Flash",
    messages=[{"role": "user", "content": "Compare CSA and HCA attention in two sentences."}],
)

ความพร้อมใช้งานเปลี่ยนเร็ว ตรวจสอบโมเดลปัจจุบันและ quota ที่ dashboard เสมอ

เส้นทางที่ 4: เครดิตทดลอง DeepSeek

DeepSeek มักให้เครดิตทดลองเล็ก ๆ กับบัญชีใหม่ (บางรอบ $1 หลังยืนยันอีเมล) ตรวจสอบได้ที่ platform.deepseek.com หลังสมัคร

เครดิต $1 ใช้งานได้เยอะมาก: V4-Flash ได้ input 7 ล้านโทเค็น หรือ V4-Pro ได้ประมาณ 570K โทเค็น

สร้างกลไกฟรีที่ไม่ขึ้นกับผู้ให้บริการใน Apidog

ข้อดีของการมี route ฟรีหลายเจ้า คือสร้าง workflow สำรองอัตโนมัติแบบ failover ได้ใน Apidog:

ดาวน์โหลด Apidog แล้วสร้างโปรเจกต์ใหม่
สร้าง environment 4 ชุด: openrouter, huggingface, chutes, deepseek-trial
ใส่ API key ที่เกี่ยวข้องและตั้ง BASE_URL ในแต่ละชุด
บันทึก POST request ไปที่ {{BASE_URL}}/chat/completions พร้อมส่งฟิลด์ model
ใช้ฟีเจอร์สลับ environment เพื่อรัน prompt เดียวกันกับทุก provider ในคลิกเดียว

แนวทางนี้เอาไปใช้กับ GPT-5.5 API route ฟรี ได้เช่นกัน

เชื่อมต่อกลไกสำรองในโค้ด

ตัวอย่าง Python failover:

import os
from openai import OpenAI, RateLimitError, APIError

PROVIDERS = [
    {
        "base_url": "https://openrouter.ai/api/v1",
        "api_key": os.environ["OPENROUTER_API_KEY"],
        "model": "deepseek/deepseek-v4-flash:free",
    },
    {
        "base_url": "https://llm.chutes.ai/v1",
        "api_key": os.environ["CHUTES_API_KEY"],
        "model": "deepseek-ai/DeepSeek-V4-Flash",
    },
    {
        "base_url": "https://api.deepseek.com/v1",
        "api_key": os.environ["DEEPSEEK_API_KEY"],
        "model": "deepseek-v4-flash",
    },
]

def call_v4(messages):
    for provider in PROVIDERS:
        try:
            client = OpenAI(
                api_key=provider["api_key"],
                base_url=provider["base_url"],
            )
            return client.chat.completions.create(
                model=provider["model"],
                messages=messages,
            )
        except (RateLimitError, APIError) as e:
            print(f"{provider['base_url']} failed: {e}")
            continue
    raise RuntimeError("all providers exhausted")

เส้นทางฟรีแต่ละเส้นทางมีประโยชน์อย่างไร

เส้นทาง	ดีที่สุดสำหรับ	แย่ที่สุดสำหรับ
OpenRouter ฟรี	การสร้างต้นแบบ, การพัฒนาประจำวัน	สิ่งใดก็ตามที่มี SLA ที่เข้มงวด
HF Inference	การเรียกใช้เพื่อสำรวจ, สมุดบันทึก	ปริมาณงานที่ต้องการความหน่วงต่ำ
Chutes	งานชุมชนเชิงทดลอง	การพึ่งพาระยะยาว
DeepSeek ทดลอง	การทดสอบที่มีความเที่ยงตรงสูง	การผลิตที่ต่อเนื่อง
โฮสต์ V4-Flash ด้วยตนเอง	งานที่ผูกกับข้อกำหนดการปฏิบัติตามกฎระเบียบ	ทีมที่ไม่มีความสามารถ GPU

การคำนวณโควตาที่สำคัญ

ตรวจสอบปริมาณงานก่อนใช้ route ฟรี:

OpenRouter ฟรี: ~100 requests/วัน/คีย์, ~50K โทเค็น/ครั้ง (ใช้งานจริงได้ 30-50 ครั้ง/วัน)
HF Inference ฟรี: อัตรารวม ~1K requests/วัน/บัญชี อาจช้าในชั่วโมงเร่งด่วน
Chutes: เปลี่ยนแปลงเร็ว ให้ถือว่าเป็นของทดลอง
DeepSeek ทดลอง ($1): ~700 calls ขนาด 10K token/ครั้ง บน V4-Flash
โฮสต์เอง: จำกัดแค่ hardware (4 × H100 = 50-150 token/sec)

ถ้า prototyping เสร็จแล้วต้องการปริมาณมากกว่า route ฟรี API แบบชำระเงินจะคุ้มกว่า (10,000 calls = ~$2.80)

เมื่อใดควรเปลี่ยนไปใช้ API แบบชำระเงิน

สัญญาณที่บอกว่าคุณควรอัปเกรดเป็นแบบชำระเงิน:

เจอ rate limit บ่อยกว่า 1 ครั้ง/วัน
ต้องต่อ provider ฟรีหลายเจ้ารองรับ workload เดียว
ต้องการ latency ที่ predictable หรือมี SLA

การเติมเงินบน platform.deepseek.com ขั้นต่ำ $2 ถูกกว่าค่าเวลา dev หลายเท่า ดู คู่มือราคา DeepSeek V4 สำหรับเรตราคา

คำถามที่พบบ่อย

ฟรีถาวรไหม? — ไม่มี route ไหนฟรีถาวร เส้นทางฟรีคือพื้นที่สำหรับสร้างต้นแบบเท่านั้น

OpenRouter :free คือ V4 จริงไหม? — จริง ใช้ infrastructure เดียวกับแบบเสียเงินแต่ถูกจำกัดอัตรา

ใช้ผลลัพธ์ route ฟรีใน production ได้ไหม? — ตรวจเงื่อนไขแต่ละ provider OpenRouter/HF inference อนุญาตเชิงพาณิชย์แต่จำกัดอัตรา DeepSeek trial เป็นไปตามข้อกำหนดหลัก

route ฟรีไหน latency ดีสุด? — เครดิตทดลอง DeepSeek ดีสุด รองลงมาคือ OpenRouter; HF กับ Chutes ขึ้นกับช่วงเวลา

โฮสต์ V4 เองฟรีไหม? — ตัว license ฟรี (MIT) ค่าใช้จ่ายคือ hardware ดู วิธีรัน DeepSeek V4 บนเครื่องของคุณ

ติดตามว่าใช้ route ไหนไปแล้ววันนี้ได้อย่างไร? — ใช้ Apidog ปักหมุด usage ใน response viewer หรือดู dashboard usage ของแต่ละ provider

วิธีใช้ DeepSeek V4: Web Chat, API และการติดตั้งด้วยตนเอง

Thanawat Wongchai — Fri, 24 Apr 2026 04:19:29 +0000

DeepSeek V4 เปิดตัวเมื่อวันที่ 23 เมษายน 2026 พร้อมเช็คพอยต์ 4 แบบ, API ที่พร้อมใช้งาน, และโมเดลน้ำหนักที่ให้สิทธิ์แบบ MIT บน Hugging Face คุณสามารถเลือกใช้งานได้หลายทางขึ้นกับความต้องการ ไม่ว่าจะเข้าถึงทันที เรียกใช้ API สำหรับ production หรือปรับใช้แบบ On-Premise บทความนี้สรุปวิธีใช้งานทั้งสามเส้นทาง พร้อมข้อดีข้อเสียและตัวอย่างเวิร์กโฟลว์สำหรับ production ที่คุณสามารถนำไปใช้ซ้ำได้ทันที ลองใช้ Apidog วันนี้ หากต้องการภาพรวมผลิตภัณฑ์ อ่าน DeepSeek V4 คืออะไร สำหรับคู่มือการใช้งาน API ดูที่ คู่มือ DeepSeek V4 API หรือหากต้องการใช้งานฟรี ดู วิธีใช้ DeepSeek V4 ฟรี เมื่อต้องการทดสอบคำขอ API จริง ดาวน์โหลด Apidog และสร้างคอลเลกชันไว้ล่วงหน้า

TL;DR

เร็วสุด: chat.deepseek.com เว็บแชทฟรี, V4-Pro เป็น default, มี 3 โหมด reasoning
สำหรับ production: https://api.deepseek.com/v1/chat/completions ใช้ model IDs deepseek-v4-pro หรือ deepseek-v4-flash
Self-hosted: ดึงน้ำหนักโมเดลจาก Hugging Face, รันสคริปต์ /inference ใน repo
เลือก Non-Think สำหรับ routing/classification, Think High สำหรับงานโค้ด/วิเคราะห์, Think Max เมื่อเน้นความแม่นยำ
ปรับ sampling ตาม DeepSeek: temperature=1.0, top_p=1.0
ใช้ Apidog เป็น API client; รูปแบบ compatible กับ OpenAI ส่งคำขอซ้ำได้ระหว่าง DeepSeek, OpenAI, Anthropic

เลือกเส้นทางที่เหมาะสมกับปริมาณงานของคุณ

เลือกวิธีใช้งานตามความต้องการและข้อจำกัดของคุณ ตารางเปรียบเทียบ:

เส้นทาง	ค่าใช้จ่าย	เวลาในการตั้งค่า	เหมาะสำหรับ
chat.deepseek.com	ฟรี	30 วินาที	ทดสอบด่วน, งาน ad-hoc
DeepSeek API	คิดค่าบริการตามโทเค็น	5 นาที	production, agent, งาน batch
V4-Flash Self-hosted	จ่ายเฉพาะฮาร์ดแวร์	ไม่กี่ชั่วโมง	ข้อกำหนดภายใน, offline inference
V4-Pro Self-hosted	จ่ายเฉพาะ cluster	หนึ่งวัน	วิจัย, ปรับแต่งโมเดล
OpenRouter / Aggregator	คิดค่าบริการตามโทเค็น	2 นาที	multi-provider backup

เส้นทางที่ 1: ใช้ V4 ในเว็บแชท

เริ่มต้นเร็วสุดด้วยอินเทอร์เฟซแชทอย่างเป็นทางการ:

ไปที่ chat.deepseek.com
เข้าสู่ระบบด้วยอีเมล, Google หรือ WeChat
V4-Pro คือโมเดลเริ่มต้น สลับโหมด Non-Think / Think High / Think Max ได้ที่ด้านบนกล่องข้อความ
เริ่มใช้งานทันที

รองรับอัปโหลดไฟล์, web search, บริบท 1M โทเค็น
มี rate limit ระดับบัญชี; ใช้งานหนักอาจช้าลงแต่ไม่โดนบล็อก
เหมาะกับ: debug, สรุป PDF, เทียบ prompt กับ GPT-5.5/Claude
ไม่เหมาะกับ: งานที่ต้องการ automation หรือ replay

เส้นทางที่ 2: ใช้ DeepSeek API

เหมาะสำหรับงานจริงและ production รองรับรูปแบบ OpenAI

ขั้นตอนรับ API Key

สมัครที่ platform.deepseek.com
เพิ่มวิธีจ่ายเงิน ขั้นต่ำเริ่ม $2
สร้าง API key ใน API Keys และคัดลอกทันที

export DEEPSEEK_API_KEY="sk-..."

Minimal API Request

curl https://api.deepseek.com/v1/chat/completions \
  -H "Authorization: Bearer $DEEPSEEK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-pro",
    "messages": [
      {"role": "user", "content": "Refactor this Python function to async. Reply with code only."}
    ],
    "thinking_mode": "thinking"
  }'

เปลี่ยน deepseek-v4-pro เป็น deepseek-v4-flash ถ้าต้องการประหยัด
เปลี่ยน thinking เป็น non-thinking สำหรับ fast-path

ตัวอย่าง Python Client

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://api.deepseek.com/v1",
)

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[
        {"role": "system", "content": "You are a concise senior engineer."},
        {"role": "user", "content": "Explain the CSA+HCA hybrid attention stack."},
    ],
    extra_body={"thinking_mode": "thinking_max"},
    temperature=1.0,
    top_p=1.0,
)

print(response.choices[0].message.content)

ตัวอย่าง Node Client

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.DEEPSEEK_API_KEY,
  baseURL: "https://api.deepseek.com/v1",
});

const response = await client.chat.completions.create({
  model: "deepseek-v4-flash",
  messages: [{ role: "user", content: "Write a fizzbuzz in Rust." }],
  temperature: 1.0,
  top_p: 1.0,
});

console.log(response.choices[0].message.content);

ดูรายละเอียดปลายทาง, ตารางพารามิเตอร์, และ error handling เพิ่มเติมใน คู่มือ DeepSeek V4 API

เส้นทางที่ 3: Automate & Replay ด้วย Apidog

ใช้ Curl สำหรับ request เดี่ยว ๆ แต่สำหรับ automation หรือ replay หลายรอบ Apidog จะสะดวกกว่า

ดาวน์โหลด Apidog สำหรับ Mac, Windows, หรือ Linux
สร้างโปรเจกต์ API ใหม่, เพิ่ม POST request ไปที่ https://api.deepseek.com/v1/chat/completions
ใส่ Authorization: Bearer {{DEEPSEEK_API_KEY}} ใน Header และเก็บ key ใน environment variable
วาง content JSON แรกแล้วบันทึก ปรับแต่งและ replay ได้ง่าย
ใช้ response viewer ในตัวเปรียบเทียบ reasoning trace ระหว่าง Non-Think กับ Think Max

คอลเลกชันเดียวกันเก็บทั้ง OpenAI GPT-5.5, Claude, DeepSeek V4 requests ได้ ทำ A/B test ข้าม provider ได้ง่าย และดู billing ทุกรายการในที่เดียว สำหรับทีมที่ใช้ Apidog อยู่แล้ว แค่เปลี่ยน Base URL จาก คอลเลกชัน GPT-5.5 API เดิมก็พร้อมใช้งานกับ V4

เส้นทางที่ 4: Self-host V4-Flash

ถ้าคุณต้องการควบคุมเต็มที่ เลือก self-host ด้วย MIT license

ฮาร์ดแวร์ที่ต้องใช้

V4-Flash (13B ใช้งาน, 284B รวม): H100/H200/MI300X 2-4 ใบ FP8, ควอนไทซ์ INT4 รันบน 80GB ได้
V4-Pro (49B ใช้งาน, 1.6T รวม): ต้องใช้ H100 16-32 ใบ สำหรับ production inference

ดึงน้ำหนักโมเดล

pip install -U "huggingface_hub[cli]"
huggingface-cli login
huggingface-cli download deepseek-ai/DeepSeek-V4-Flash \
  --local-dir ./models/deepseek-v4-flash \
  --local-dir-use-symlinks False

V4-Flash ~500GB (FP8), V4-Pro หลาย TB

เรียกใช้งาน Inference

pip install "vllm>=0.9.0"

vllm serve deepseek-ai/DeepSeek-V4-Flash \
  --tensor-parallel-size 4 \
  --max-model-len 1048576 \
  --dtype auto

เมื่อ vLLM ขึ้นแล้ว ใช้ client ที่ compatible กับ OpenAI ชี้ไป http://localhost:8000/v1
คอลเลกชัน Apidog เดิมใช้ต่อได้ แค่เปลี่ยน Base URL

การใช้ prompt V4 อย่างมีประสิทธิภาพ

ระบุโหมด reasoning ที่ต้องการ กำหนด thinking_mode ตรงกับงาน อย่าให้โมเดลเลือกเอง
System Prompt สำหรับ persona เท่านั้น ใส่รายละเอียดงานใน user prompt แทน system prompt
งานโค้ดแนบ test harness เช่นเดียวกับ LiveCodeBench, แปะ test case ที่ไม่ผ่านด้วย จะได้โค้ดที่ผ่านจริง

สำหรับ context ยาว (หลายแสนโทเค็น) ให้เน้นเนื้อหาสำคัญไว้ต้น/ท้าย context window แม้จะมี Hybrid Attention ก็ตาม

การควบคุมค่าใช้จ่าย

เริ่มที่ V4-Flash + Non-Think แล้วค่อยอัปเกรดเมื่อจำเป็น
จำกัด max_tokens 1M คือ limit ไม่ใช่เป้าหมาย คำตอบส่วนใหญ่พอดีที่ 2,000 โทเค็น
ใน Apidog กำหนด environment variable DEEPSEEK_API_KEY แยก dev/prod
Apidog แสดง token usage ทุก request

ย้ายจาก DeepSeek V3 หรือโมเดลอื่น

จาก deepseek-chat / deepseek-reasoner: เปลี่ยน model ID เป็น deepseek-v4-pro หรือ deepseek-v4-flash ก่อน 24 ก.ค. 2026
จาก OpenAI GPT-5.x: เปลี่ยน Base URL เป็น https://api.deepseek.com/v1 และ model ID, รูปแบบ request อื่นใช้เหมือนเดิม (ดูคู่มือ GPT-5.5 API)
จาก Anthropic Claude: ใช้ https://api.deepseek.com/anthropic หรือปรับเป็นรูปแบบ OpenAI

FAQ

ต้องมีบัญชีแบบชำระเงินไหม? เว็บแชทฟรี API ต้องเติมเงินขั้นต่ำ $2 ดู วิธีใช้ DeepSeek V4 ฟรี

ควรใช้รุ่นไหนเป็น default? เริ่มที่ V4-Flash + Non-Think วัดคุณภาพก่อนอัปเกรด

V4 รันบน MacBook ได้ไหม? V4-Flash รันบน M3 Max/M4 Max (128GB RAM) ได้แต่ช้ามาก V4-Pro ไม่เหมาะ ใช้ API หรือเว็บแชทจะสะดวกกว่า

V4 รองรับฟังก์ชันและ tool calling ไหม? รองรับผ่าน OpenAI tools array และรูปแบบ Anthropic

จะ stream response ยังไง? ใส่ stream: true ใน request body ได้ SSE stream compatible กับ OpenAI เลย

มี rate limit ไหม? Hosted API มี limit ตามระดับ ดู api-docs.deepseek.com Self-hosted ไม่มี limit นอกจากกำลังฮาร์ดแวร์

DeepSeek V4 คืออะไร

Thanawat Wongchai — Fri, 24 Apr 2026 04:18:26 +0000

DeepSeek ได้เปิดตัว V4 อย่างเป็นทางการเมื่อวันที่ 23 เมษายน 2026 โดยไม่ได้เป็นเพียงอัปเดตเล็กน้อย แต่เป็นการเปิดตัวเช็คพอยต์ใหม่ 4 รุ่นพร้อมกัน นำโดย DeepSeek-V4-Pro ซึ่งมาพร้อมกับพารามิเตอร์รวม 1.6 ล้านล้าน, ใบอนุญาต MIT, และวินโดว์บริบท 1 ล้านโทเค็น ส่วนรุ่น DeepSeek-V4-Flash ที่เล็กกว่ามี 2.84 แสนล้านพารามิเตอร์ ผลการทดสอบแสดงให้เห็นว่า V4-Pro เหนือกว่า Claude Opus 4.6 ใน LiveCodeBench และ Codeforces และใกล้เคียงกับ GPT-5.4 xHigh ใน MMLU-Pro

ทดลองใช้ Apidog วันนี้

ถ้าคุณเป็นนักพัฒนาที่ต้องการเปรียบเทียบหรือย้ายจาก Claude, GPT-5.5 หรือ Qwen มาใช้ DeepSeek V4 บทความนี้จะสรุปรายละเอียดสำคัญเกี่ยวกับตัวโมเดล การเปลี่ยนแปลงจาก V3.2 สถาปัตยกรรมที่มีผลต่อประสิทธิภาพ และแนวทางการใช้งานจริงในวันนี้

สำหรับแนวทางปฏิบัติสำหรับนักพัฒนาโดยตรง เข้าอ่าน คู่มือ API ของ DeepSeek V4, วิธีใช้ฟรี และ คู่มือฉบับเต็ม รูปแบบ request ของ DeepSeek V4 เข้ากันได้กับ OpenAI ดังนั้นคุณสามารถสร้าง collection ล่วงหน้าใน Apidog โดยไม่ต้องรอรับ API Key

สรุป

DeepSeek V4 คือกลุ่มโมเดล Mixture-of-Experts เปิดตัว 23 เม.ย. 2026 ใต้ ใบอนุญาต MIT
เปิดตัวพร้อมกัน 4 เช็คพอยต์: V4-Pro, V4-Pro-Base, V4-Flash, V4-Flash-Base
V4-Pro: 1.6 ล้านล้านพารามิเตอร์ (active 4.9 หมื่นล้าน), V4-Flash: 2.84 แสนล้าน (active 1.3 หมื่นล้าน)
ทั้งคู่รองรับ วินโดว์บริบท 1 ล้านโทเค็น และ reasoning mode 3 แบบ: Non-Think, Think High, Think Max
คะแนน: LiveCodeBench 93.5, Codeforces 3206, MMLU-Pro 87.5 (Pro)
API ใช้งานได้ที่ api.deepseek.com (model ID: deepseek-v4-pro, deepseek-v4-flash); น้ำหนักโมเดลดาวน์โหลดได้จาก Hugging Face และ ModelScope

DeepSeek V4 คืออะไร

DeepSeek V4 เป็น Mixture-of-Experts รุ่นต่อจาก V3/V3.2 โดยโครงสร้างเปลี่ยนใหม่หมด V4-Pro จะเปิดใช้งาน 4.9 หมื่นล้านพารามิเตอร์ จากทั้งหมด 1.6 ล้านล้านต่อโทเค็น ทำให้ค่า inference ต่อโทเค็นใกล้เคียงโมเดล 5 หมื่นล้านพารามิเตอร์ทั่วไป อ่านรายละเอียดเทคนิคได้ที่ การ์ดโมเดล DeepSeek V4

เช็คพอยต์ที่เปิดตัว

DeepSeek-V4-Pro — เรือธง, 1.6T พารามิเตอร์, 49B active, 1M context, เหมาะกับ API
DeepSeek-V4-Pro-Base — pretrain base สำหรับ custom fine-tune
DeepSeek-V4-Flash — เล็กลง, 284B พารามิเตอร์, 13B active, 1M context, เหมาะกับงาน low-latency/รัน local H100
DeepSeek-V4-Flash-Base — base สำหรับ Flash

ทั้ง 4 รุ่นใช้ MIT License — แตกต่างจาก GPT-5.5/Claude ที่ปิดและมีค่าใช้จ่ายสูง DeepSeek V4-Pro แจกน้ำหนักโมเดลให้ดาวน์โหลด ปรับแต่ง โฮสต์เอง ได้เต็มที่

มีอะไรเปลี่ยนแปลงจาก V3.2

V3 แข็งแกร่งเรื่อง reasoning/coding อยู่แล้ว V4 ยกเครื่อง attention stack และ training pipeline ใหม่หมด เพื่อรองรับ context ยาวและประสิทธิภาพสูง

ความสามารถ	V3.2	V4-Pro
พารามิเตอร์ทั้งหมด	685B	1.6T
พารามิเตอร์ที่ใช้งานอยู่	37B	49B
วินโดว์บริบท	128K	1M
FLOPs ในการอนุมาน (บริบท 1M)	พื้นฐาน	27% ของ V3.2
แคช KV (บริบท 1M)	พื้นฐาน	10% ของ V3.2
ความแม่นยำ	FP8	FP4 + FP8 ผสม
ใบอนุญาต	DeepSeek License	MIT
โหมดการให้เหตุผล	เดี่ยว	สาม

จุดเปลี่ยนหลักของ V4:

Hybrid attention stack - ผสม Compressed Sparse Attention กับ Heavily Compressed Attention ลด cache KV เหลือ 10%
Manifold-Constrained Hyper-Connections - รักษา gradient stability ในความลึกสูง
Muon optimizer - เร่ง convergence ให้เร็วขึ้น

ชุดข้อมูล training โตเกิน 32T โทเค็น และใช้ 2-phase post-training pipeline (specialist pretraining + on-policy distillation)

ผลการทดสอบที่สำคัญ

V4-Pro นำด้าน coding/knowledge มีจุดอ่อนที่ retrieval context ขนาดใหญ่

V4-Flash (รุ่นเล็ก) ได้ MMLU-Pro 86.2, GPQA 88.1, LiveCodeBench 91.6, Codeforces 3052, SWE Verified 79.0 เหมาะสำหรับงาน local inference ดู การ์ด Flash สำหรับรายละเอียด

สรุปสั้น:

V4-Pro ชนะด้านโค้ด/การให้เหตุผล
General knowledge ยังเป็นรอง Gemini 3.1 Pro
Context retrieval 1M โทเค็น Claude ยังคงดีที่สุด

โหมดการให้เหตุผลสามโหมด

ทุกเช็คพอยต์ V4 รองรับ reasoning mode 3 แบบ ใช้พารามิเตอร์เดียว thinking_mode ใน API

Non-Think — inference เร็ว, ไม่สร้าง reasoning token, เหมาะกับ classification/summary
Think High — default สำหรับงานซับซ้อน, สร้าง reasoning ก่อนตอบ, เหมาะกับ task ที่ต้องวางแผน
Think Max — reasoning token ยาวสุด, context ขั้นต่ำ 384K, ใช้ตอนต้องการความแม่นยำสูงสุด

แนะนำ temperature=1.0, top_p=1.0 ทุกโหมด

สถาปัตยกรรมในภาษาที่เข้าใจง่าย

Hybrid attention — Compressed Sparse Attention สำหรับโทเค็นสำคัญ + Heavily Compressed Attention สำหรับโทเค็นส่วนที่เหลือ ลด FLOPs/ใช้ cache KV น้อย
Manifold-Constrained Hyper-Connections — residual connection แบบใหม่ ลด gradient chaos ใน deep network
Muon optimizer — แทน AdamW, เร็วกว่าและเหมาะกับ MoE

ทั้งสามอย่างนี้ทำงานร่วมกันในสเกลล้านล้านพารามิเตอร์โดยไม่ล้ม training

สถานะการใช้งานในปัจจุบัน

DeepSeek เปิดตัว API และเผยแพร่น้ำหนักโมเดลพร้อมกัน

ช่องทาง	การเข้าถึง
chat.deepseek.com	แชทเว็บฟรี, V4-Pro เป็นค่าเริ่มต้น, ต้องเข้าสู่ระบบ
DeepSeek API	ใช้งานที่ `api.deepseek.com`; model ID: `deepseek-v4-pro`, `deepseek-v4-flash`
Hugging Face	V4-Pro, V4-Flash (MIT)
ModelScope	น้ำหนักสำรองสำหรับผู้ใช้ในจีน
OpenRouter/aggregator	คาดว่าจะพร้อมในไม่กี่วัน
`deepseek-chat` / `deepseek-reasoner`	เลิกใช้งาน 24 ก.ค. 2026

หมายเหตุ: ถ้าใช้งาน <code>deepseek-chat</code> production อยู่ ให้รีบย้ายเป็น <code>deepseek-v4-pro</code> หรือ <code>deepseek-v4-flash</code> ภายใน 3 เดือน

เปรียบเทียบกับ GPT-5.5 และ Claude

ต้นทุน — V4-Pro/Flash เป็น open weights รันเองได้, GPT-5.5/Claude ปิด ถ้าโฮสต์เองได้ V4 คุ้มกว่ามาก
โค้ดดิ้ง — V4-Pro ชนะ GPT-5.5/Claude ใน LiveCodeBench และ Codeforces
Knowledge — Gemini 3.1 Pro ยังนำ, V4-Pro เสมอ GPT-5.5 ใน MMLU-Pro, SimpleQA-Verified V4 ชนะทั้งสอง
Long context retrieval — Claude Opus ยังแม่นสุด
License — MIT ใช้ในผลิตภัณฑ์ได้จริง ไม่มีเงื่อนไข

จะสร้างอะไรด้วย DeepSeek V4

4 งานที่เหมาะกับ V4:

Agentic code loop — debugging/refactor หลายไฟล์, testing อัตโนมัติ, ตรวจสอบทุกคำขอด้วย Apidog
Long-document reasoning — 1M context เหมาะกับ monorepo & เอกสารยาว ใช้โหมด Think High
Self-hosted AI product — ถ้าต้อง inference ในองค์กร V4-Flash คือ open weights ตัวแรกที่คุณภาพระดับ API ชั้นนำ
Research/fine-tune — เช็คพอยต์ Base สำหรับ custom training + ข้อมูลโดเมน

ไม่เหมาะกับ: classification ปริมาณมาก, embedding retrieval, หรือ chat/prompt สั้น ใช้รุ่น DeepSeek เก่าจะคุ้มค่ากว่า

ราคาโดยสรุป

API ของ V4 ยังไม่ประกาศราคาทั้งหมด V3.2 ประมาณ $0.28/ล้านโทเค็น input, $0.42/ล้าน output คาดว่า V4-Flash ราคาพอๆ กัน V4-Pro แพงกว่าเล็กน้อย คู่แข่งปิดเริ่ม $5–15/ล้านโทเค็น input แม้ V4-Pro ราคาขึ้น 3 เท่าก็ยังต่ำกว่าคู่แข่งหลักมาก ดูราคาปัจจุบันที่ หน้ากำหนดราคา DeepSeek

วิธีทดสอบ V4 ในวันนี้

3 ช่องทางหลัก (เรียงตามความเร็ว):

Web chat — เข้า chat.deepseek.com ล็อกอิน เลือก V4-Pro, ปรับ Think High ได้ใน UI ฟรีทันที
API — ขอ API Key, ชี้ client ที่ https://api.deepseek.com, ใส่ "model": "deepseek-v4-pro" รองรับ format เดียวกับ OpenAI ตัวอย่าง request:

{
  "model": "deepseek-v4-pro",
  "messages": [{"role": "user", "content": "Explain MoE architecture"}]
}

ดูคู่มือเต็ม ที่นี่

Run local weights — ดาวน์โหลดจาก Hugging Face หรือ ModelScope
- V4-Flash ใช้ H100 2-4 ตัว
- V4-Pro ต้องการคลัสเตอร์ใหญ่
- โค้ด inference อยู่ในโฟลเดอร์ /inference ของ repo

สำหรับการวนซ้ำ prompt ด้วย Apidog หรือวิธีใช้งานฟรี ดู คู่มือ DeepSeek V4 และ วิธีใช้ฟรี ดาวน์โหลด Apidog และสร้าง collection พร้อมทดสอบทันที

คำถามที่พบบ่อย

DeepSeek V4 เป็นโอเพ่นซอร์สจริงหรือ?

ใช่ ทั้ง 4 เช็คพอยต์เป็น MIT License ใช้เชิงพาณิชย์/แก้ไข/แจกจ่ายซ้ำได้

ต้องมี GPU cluster เพื่อรัน V4-Flash ไหม?

ต้องใช้ H100/H200 2–4 ตัวสำหรับ V4-Flash เต็มประสิทธิภาพ น้อยกว่านี้ถ้า quantize V4-Pro ต้องคลัสเตอร์ขนาดใหญ่ ถ้าไม่มีฮาร์ดแวร์ ใช้ API หรือ chat.deepseek.com

V4 เข้าสู่ DeepSeek API เมื่อไร?

เปิดให้ใช้งานแล้วตั้งแต่ 23 เม.ย. 2026 (deepseek-v4-pro/deepseek-v4-flash) รุ่นเก่าเลิกใช้ 24 ก.ค. 2026

เปรียบเทียบกับ Kimi/Qwen อย่างไร?

V4-Pro ได้คะแนน LiveCodeBench/Codeforces สูงกว่า Kimi K2/Qwen 3 Max เลือกตามภาระงานที่ตรงกับคุณ

Fine-tune V4 ด้วยข้อมูลตัวเองได้หรือไม่?

ได้ ใช้เช็คพอยต์ Base + ข้อมูลโดเมน + pipeline SFT มาตรฐาน MIT License ครอบคลุมการแจกจ่ายโมเดล fine-tune

V4 ใช้กับเครื่องมือ/SDK OpenAI เดิมได้ไหม?

ได้ API รองรับ format ของ OpenAI และ Anthropic (https://api.deepseek.com และ /anthropic) เปลี่ยน base URL ก็ใช้ client เดิมได้ ดู คู่มือ GPT-5.5 API สำหรับรายละเอียด format

ราคา GPT-5.5: เจาะลึกค่าใช้จ่าย API, Codex และ ChatGPT (เมษายน 2026)

Thanawat Wongchai — Fri, 24 Apr 2026 02:34:19 +0000

OpenAI ได้ประกาศขึ้นราคาต่อโทเค็นเป็นสองเท่าสำหรับ GPT-5 ด้วยการเปิดตัว GPT-5.5 เมื่อวันที่ 23 เมษายน 2026 โดยราคา Input เพิ่มจาก $2.50 เป็น $5.00 ต่อล้านโทเค็น และ Output จาก $15.00 เป็น $30.00 ต่อล้านโทเค็น ราคา Pro ยังคงเดิมที่ $30 / $180 บทความนี้จะลงรายละเอียดต้นทุนจริงและแนวทางการประมาณภาระงานก่อนเลือกโมเดล

ทดลองใช้ Apidog วันนี้

คู่มือนี้เน้นวิธีการประเมินต้นทุน: ครอบคลุมโครงสร้างราคา API มาตรฐาน, Batch, Flex, Priority, ราคา Pro, ข้อจำกัด Codex ต่อแผน และวิธีคำนวณภาระงานจริงก่อนย้ายไปโมเดลใหม่

ดูภาพรวมโมเดลที่ GPT-5.5 คืออะไร และคู่มือสำหรับนักพัฒนาที่ วิธีใช้ GPT-5.5 API

สรุป (TL;DR)

รูปแบบบริการ	Input / ล้าน	Output / ล้าน
API มาตรฐาน GPT-5.5	$5.00	$30.00
API GPT-5.5 Pro	$30.00	$180.00
GPT-5.5 Batch (ลด 50 %)	$2.50	$15.00
GPT-5.5 Flex (ลด 50 %)	$2.50	$15.00
GPT-5.5 Priority (2.5 เท่า)	$12.50	$75.00
API มาตรฐาน GPT-5.4	$2.50	$15.00
API GPT-5.4-mini	$0.25	$2.00

GPT-5.5 มีราคาเป็น 2 เท่าของ GPT-5.4 ต่อโทเค็น แต่ประสิทธิภาพต่อโทเค็นอาจดีขึ้นประมาณ 20% (อ้างอิงจาก Intelligence-Index)

ตัวเลขสำคัญ

GPT-5.5: $5.00 ต่อล้านโทเค็นอินพุต, $30.00 ต่อล้านโทเค็นเอาต์พุต
GPT-5.5 Pro: $30.00 ต่อล้านโทเค็นอินพุต, $180.00 ต่อล้านโทเค็นเอาต์พุต
Context window: 1 ล้านโทเค็น ทั้งสองรุ่น โทเค็น reasoning นับรวมทั้งใน window และการคิดเงินเอาต์พุต

รายละเอียดอัปเดตราคาแบบเป็นทางการที่ หน้าการกำหนดราคา API

Batch, Flex และ Priority

มี 3 ระดับราคาทางเลือก:

Batch API

เหมาะสำหรับงานออฟไลน์หรืองานที่รอได้ ส่ง request ผ่าน Batch endpoint จะได้ราคาถูกลง 50% (รอผลไม่เกิน 24 ชั่วโมง)

ประเมินชุดข้อมูลใหญ่
เติมข้อมูลย้อนหลัง
งานที่ latency ไม่สำคัญ

ราคาต่อโทเค็นเท่ากับ GPT-5.4 มาตรฐาน

Flex Mode

ลด 50% เช่นเดียวกับ Batch แต่เวลารออาจผันผวน (วินาที-นาที) เหมาะสำหรับงานที่ทน latency ได้ แลกกับราคาถูกลง

Priority Mode

จ่าย 2.5 เท่าของราคาปกติ ($12.50 / $75.00 ต่อล้านโทเค็น) ได้ queue ที่เร็วขึ้น เหมาะสำหรับ use case ที่ latency สำคัญต่อประสบการณ์ผู้ใช้

วิธีคำนวณต้นทุนโหมด reasoning

การใช้ reasoning.effort ที่สูงขึ้น ไม่เปลี่ยนราคาต่อโทเค็น แต่เพิ่มจำนวนโทเค็นที่ใช้ต่อ request

ความพยายาม	ตัวคูณโทเค็นเอาต์พุต	เมื่อใช้
`ต่ำ` (default)	1×	ใช้งานทั่วไป
`ปานกลาง`	1.3–2×	เขียนโค้ดหลายขั้นตอน, สร้างข้อมูลมีโครงสร้าง
`สูง`	2–4×	งานเชิงลึก, ตรวจสอบ critical
`สูงมาก`	3–8×	Agent loop + tool chain, วางแผนซับซ้อน

ตัวอย่าง: เรียก xhigh 1 ครั้งบน prompt ยาว อาจใช้ reasoning token ถึง 20,000 โทเค็น คิดเป็น $0.60 เฉพาะ reasoning (ที่ $30/ล้าน) ยังไม่รวม output token ปกติ

ดังนั้นควรจัดงบประมาณตามโทเค็นที่ใช้จริง ไม่ใช่จำนวน request

ราคา Codex

Codex ผูกกับแผน ChatGPT ไม่ใช่คิดเงินต่อโทเค็น โครงสร้างวันที่ 23 เม.ย. 2026:

แผน	การเข้าถึง Codex	GPT-5.5	หมายเหตุ
ฟรี	มี (จำกัดเวลา)	มี	จำกัดการใช้งานรายสัปดาห์
Go	มี (จำกัดเวลา)	มี	จำกัด 2 เท่าแผนฟรี
Plus ($20 / เดือน)	มี	มี	จำกัดมาตรฐาน
Pro ($200 / เดือน)	มี	มี + โหมด reasoning + Pro	จำกัดสูงสุดต่อผู้ใช้
Business	มี	มี	คิดตาม seat
Enterprise / Edu	มี	มี	ตามสัญญา

ถ้าคุณใช้โค้ดผ่านเทอร์มินัลบ่อยๆ แผน Plus หรือ Pro จะคุ้มกว่าจ่าย Batch ถ้าคุณใช้โทเค็นเยอะ ดูคู่มือใช้ฟรี

เปรียบเทียบ GPT-5.5 กับโมเดลอื่น

เลือกใช้ GPT-5.5 เมื่อใด หรือใช้ GPT-5.4/mini ดีกว่า? ให้คำนวณจากปริมาณ output ต่อภาระงาน

โมเดล	Input / ล้าน	Output / ล้าน	ต้นทุนต่อ 1 พันโทเค็นเอาต์พุต
GPT-5.4-mini	$0.25	$2.00	$0.0020
GPT-5.4	$2.50	$15.00	$0.0150
GPT-5.5	$5.00	$30.00	$0.0300
GPT-5.5 Pro	$30.00	$180.00	$0.1800

แนวทางเลือก (rule of thumb):

งาน output เยอะ เสี่ยงต่ำ: GPT-5.4-mini
งาน production ทั่วไป: GPT-5.4
coding/agentic/research ซับซ้อน: GPT-5.5
output critical (ผิดไม่ได้): GPT-5.5 Pro

ตัวอย่าง: คำนวณต้นทุน per mission ของ coding agent

สมมติ task coding agent ผ่าน API GPT-5.5, reasoning.effort: "medium"

Input token / mission (repo context + prompt): ~15,000
Output token / mission (code+explanation): ~3,000
Reasoning token / mission (ปานกลาง): ~6,000

ต้นทุนต่อภารกิจ (standard):

Input: 15K × $5.00 / ล้าน = $0.075
Output: (3K + 6K) × $30.00 / ล้าน = $0.27
รวม: $0.345/mission

ถ้าใช้ GPT-5.4:

Input: 15K × $2.50 / ล้าน = $0.0375
Output: 9K × $15.00 / ล้าน = $0.135
รวม: $0.1725/mission

GPT-5.5 ต้นทุนต่อภารกิจสูงขึ้นเท่าตัว การอัปเกรดคุ้ม ก็ต่อเมื่องานที่สำเร็จเพิ่มขึ้นจนลด retry/rewrite ได้มาก (เช่น ลด manual intervention จาก 1 ใน 8 เหลือ 0)

5 แนวทางควบคุมต้นทุน GPT-5.5 ที่ควรทำตั้งแต่ต้น

จำกัด max_output_tokens อย่างเข้มงวด กำหนดทุก API call, default 2,000 เว้นแต่จำเป็นต้องได้ output ยาว
ใช้ JSON schema เข้มงวด ลดโอกาส output ผิดรูปแบบ/ต้อง retry
Route ตามความยาก งานง่ายส่งไป GPT-5.4-mini, งานยากไป GPT-5.5 Router 10 บรรทัดประหยัดต้นทุนมากกว่าปรับ prompt
ใช้ Batch สำหรับงานออฟไลน์ (evaluation, backfill, nightly reports) ลด 50%
Track usage.reasoning_tokens Monitor reasoning token สูง แจ้งเตือนถ้า usage พุ่ง

เปรียบเทียบค่าใช้จ่ายรายเดือนแต่ละแผน

แผน	ราคาต่อเดือน	เหมาะสำหรับ
ฟรี	$0	ทดลอง GPT-5.5 ผ่าน Codex
Go	$4 / เดือน	นักเรียน/ผู้ใช้ทั่วไป จำกัด 2 เท่าแผนฟรี
Plus	$20 / เดือน	Dev ที่ใช้ Codex+ChatGPT ทุกวัน
Pro	$200 / เดือน	ผู้ใช้ขั้นสูง ต้องการ reasoning/pro
Business	$25 / user / เดือน	ทีมที่ต้องการ workspace
Enterprise/Edu	custom	ตามสัญญา + SLA

ถ้าใช้ output token เกิน ~4 ล้าน/เดือน การใช้ ChatGPT Pro + Codex CLI จะถูกกว่า API pay-as-you-go (ถ้า workload อยู่ใน context window 400K ของ CLI)

สัญญาณเปลี่ยนราคาที่ควรจับตา

GA GPT-5.5 API: ราคาอาจลดลง ถ้า OpenAI ถูกบีบจากคู่แข่ง (Claude, Gemini, โมเดล open-weight ฯลฯ)
Pro democratization: แผน Pro อาจลดราคาใน 3-6 เดือนหลังเปิดตัว (แต่ไม่แน่นอน)

FAQ

การแคช input ลดต้นทุนได้จริงหรือ? ลดได้ โทเค็นที่แคชจะคิดเงินถูกลง (ดู multiplier ใน หน้าการกำหนดราคาของ OpenAI) แนะนำ cache prompt/tool schema/repo context ที่ใช้ซ้ำ

มี volume discount ไหม? ยังไม่มีประกาศ Enterprise มัก custom rate ติดต่อ sales ถ้าใช้เกิน 7 หลัก/ปี

Reasoning mode คิดเงินเพิ่มหรือไม่? ไม่ อัตราต่อโทเค็นคงที่ แต่ใช้โทเค็นมากขึ้น

Codex CLI คิดเงินแยกจาก API มั้ย? ถ้า login ด้วย ChatGPT จะคิดตามแผน ChatGPT ถ้าใช้ API key จะคิดตาม usage บัญชีนั้น

วิธีที่ถูกสุดสำหรับลอง GPT-5.5? ใช้ Free หรือ Go plan + Codex CLI ดู คู่มือใช้ฟรี

วิธีใช้ GPT-5.5 ฟรี ด้วย Codex

Thanawat Wongchai — Fri, 24 Apr 2026 02:31:42 +0000

OpenAI เปิดตัว GPT-5.5 เมื่อวันที่ 23 เมษายน 2026 และเพื่อเป็นการฉลองการเปิดตัว ได้เปิดให้ใช้งาน Codex กับแพลน ChatGPT ทุกแพลน รวมถึง Free และ Go เป็นเวลาจำกัด จุดสำคัญในประกาศนี้คือเส้นทางฟรีที่เร็วที่สุดในการเข้าถึงโมเดลใหม่: ติดตั้ง Codex CLI เข้าสู่ระบบด้วยบัญชี ChatGPT และใช้งาน GPT-5.5 ผ่านเทอร์มินัลได้โดยไม่ต้องใช้ API key และบัตรเครดิต

ทดลองใช้ Apidog วันนี้

คู่มือนี้จะแนะนำขั้นตอนการติดตั้ง, ตัวเลือกการยืนยันตัวตน, การสลับโมเดล, ข้อจำกัดที่คุณจะเจอ และวิธีนำ Codex เข้ามาใช้ในขั้นตอนการทำงานเขียนโค้ดจริง สำหรับภาพรวมของโมเดล โปรดดูที่ GPT-5.5 คืออะไร สำหรับเส้นทางฟรีอื่นๆ (เครดิตทดลองใช้, ตัวรวบรวม) โปรดดู คู่มือการใช้งาน GPT-5.5 ฟรี ของเรา

สรุป (TL;DR)

Codex CLI รัน GPT-5.5 กับ repository ในเครื่องของคุณ ด้วยหน้าต่างบริบท (context window) ขนาด 400K
ChatGPT Free, Go, Plus, Pro, Business, Enterprise, และ Edu ทั้งหมดสามารถเข้าถึง Codex ได้; สำหรับ Free และ Go เป็นแบบ จำกัดเวลา
ติดตั้งด้วย npm install -g @openai/codex หรือ brew install codex
ลงชื่อเข้าใช้ผ่าน ChatGPT OAuth ในเบราว์เซอร์ หรือใช้ Device-code flow บนเครื่องที่ไม่มีหน้าจอ (headless boxes)
สลับโมเดลระหว่างเซสชันด้วย /model gpt-5.5; ตรวจสอบโควต้าด้วย /status
จับคู่ CLI กับ Apidog เพื่อสร้างและทดสอบ API ที่จะใช้งานจริง

ทำไม Codex ถึงเป็นเส้นทางฟรีที่ง่ายที่สุด

API ของ OpenAI มีค่าใช้จ่ายเป็นค่าเริ่มต้น; GPT-5.5 บนเอนด์พอยต์ Responses มีค่าใช้จ่าย 5 ดอลลาร์ต่อล้านโทเค็นอินพุต และ 30 ดอลลาร์ต่อล้านโทเค็นเอาต์พุตเมื่อเปิดให้ใช้งานทั่วไป Codex ลดขั้นตอนนั้นโดยการห่อหุ้มโมเดลเดียวกันไว้ใน CLI ที่ยืนยันตัวตนด้วยบัญชี ChatGPT แทนที่จะเป็น API key ระดับของแพลนจะเป็นตัวกำหนดอัตราการจำกัด; โมเดลที่ทำงานอยู่เบื้องหลังคือ GPT-5.5 ของจริง

ติดตั้ง Codex CLI

เลือกหนึ่งในสองวิธีติดตั้ง:

# npm (ข้ามแพลตฟอร์ม)
npm install -g @openai/codex

# หรือ Homebrew (macOS / Linux)
brew install codex

ตรวจสอบการติดตั้ง:

codex --version

ควรเห็นเวอร์ชันอย่างน้อย 0.28.0 ขึ้นไป เพื่อให้แน่ใจว่ารองรับ GPT-5.5

ยืนยันตัวตนด้วยบัญชี ChatGPT

รัน CLI ครั้งแรก จะมีตัวเลือกลงชื่อเข้าใช้:

Browser OAuth (สำหรับเครื่องคอมพิวเตอร์ส่วนตัว)

codex

ระบบจะเปิดแท็บเบราว์เซอร์ให้ลงชื่อเข้าใช้ด้วยอีเมล ChatGPT เซสชันจะถูกบันทึกไว้สำหรับการใช้งานครั้งถัดไป

Device code flow (สำหรับเครื่องไม่มีหน้าจอ/เซิร์ฟเวอร์)

codex login --device-auth

เทอร์มินัลจะแสดงรหัสและ URL เปิด URL บนอุปกรณ์อื่น กรอกรหัสนั้นเพื่อยืนยัน

API key สำรอง

ถ้ามี API key แบบชำระเงิน สามารถใช้แทนได้:

printenv OPENAI_API_KEY | codex login --with-api-key

เส้นทางนี้จะเรียกเก็บเงินจากบัญชี API key ที่ผูกไว้

เลือก GPT-5.5 เป็นโมเดล

Codex จะเลือกโมเดล "แนะนำ" ให้ตามแพลนที่ใช้งาน หากต้องการสลับด้วยตัวเอง:

ระหว่างเซสชัน

/model gpt-5.5

ขณะรัน CLI

codex --model gpt-5.5

ตรวจสอบโควต้าที่เหลือ

/status

ผลลัพธ์จะแสดงงบประมาณข้อความ, context window, และเวลาหมดอายุของสิทธิ์ทดลอง

เซสชันแรก: ตัวอย่างที่ใช้งานได้จริง

Codex เปิดอินเทอร์เฟซเทอร์มินัลเต็มหน้าจอ สามารถอ่าน repo, รันคำสั่ง, แก้ไขไฟล์ เช่น

cd ~/Projects/my-app
codex --model gpt-5.5

ภายในเซสชัน:

> Read README.md, then open scripts/deploy.sh and summarize what it does in five bullets.

Codex จะสรุปรายการ และสามารถสั่งให้ refactor ต่อได้ เช่น

> Refactor deploy.sh so it exits on any failed step, and add a dry-run flag. Keep backwards compatibility.

Codex จะแสดง diff, รออนุมัติ, แล้วนำไปใช้ สามารถรันทดสอบได้ทันที

> Run the deploy test suite and show me the failing case.

ทำซ้ำวงจรนี้จนกว่าทดสอบจะผ่าน

สิ่งที่ Codex ให้คุณได้ (ที่ API ตรงไม่ให้)

จุดเด่นของ CLI Codex:

บริบทของ Repository: อ่านโครงสร้างไฟล์, ส่งไฟล์ให้โมเดลจัดการโดยตรง
การรันคำสั่งพร้อมการอนุมัติ: ต้องอนุมัติก่อนรัน ลดความเสี่ยงเชลล์
แสดง diff ก่อนเขียนไฟล์: เห็นความต่าง, ปฏิเสธ/ยอมรับ/แก้ไขก่อน commit
การคงอยู่ของเซสชัน: กลับมาใช้งานต่อได้อย่างต่อเนื่องในแต่ละโปรเจกต์

หากต้องการใช้ API ตรง ดู คู่มือ API ของ GPT-5.5

อัตราการจำกัดและขีดจำกัดสูงสุดต่อแพลน

ตัวเลขล่าสุด (23 เม.ย. 2026):

แพลน	การเข้าถึง GPT-5.5 ใน Codex	ขีดจำกัดรายสัปดาห์
Free	ได้ (จำกัดเวลา)	จำกัดมาก เหมาะสำหรับโปรเจกต์ต้นแบบ
Go	ได้ (จำกัดเวลา), 2 เท่า Free	น้อย
Plus	ได้	ปานกลาง
Pro	ได้, ขีดจำกัดสูงสุดผู้ใช้งานเดี่ยว	สูง
Business	ได้, ตามจำนวนผู้ใช้ (seat-based)	สูงต่อผู้ใช้หนึ่งราย
Enterprise/Edu	ได้, ตามสัญญา	กำหนดเอง

เมื่อถึงขีดจำกัด Codex จะแจ้ง error เฉพาะแพลน ใช้ /status เพื่อตรวจสอบโควต้าที่เหลือ

การผสานรวมกับ Editor และ IDE

เซสชัน Codex CLI ใช้ข้อมูลรับรองเดียวกันกับส่วนเสริม VS Code, ปลั๊กอิน JetBrains, และแอป Codex บนคลาวด์ ไม่ต้องลงชื่อเข้าใช้ซ้ำ

สำหรับผู้ใช้ Apidog:

สร้างต้นแบบคำขอใน Codex CLI (รัน GPT-5.5 prompt กับไฟล์นี้)
ส่งออก prompt/เอาต์พุตที่มีโครงสร้างไปยังคอลเลกชัน Apidog เพื่อแชร์กับทีม
เปลี่ยนไปใช้ API โดยตรงเมื่อพร้อม

ดู Apidog ใน VS Code สำหรับการเชื่อมโยงกับ editor

การรักษาความปลอดภัยบนแพลน Free/Go

ตั้งค่าสำคัญในวันแรก:

อนุมัติการเขียนไฟล์เสมอ: ใน ~/.codex/config.json ใส่ "autoApproveWrites": false
กำหนดขอบเขตพื้นที่ทำงาน: รัน codex ในไดเรกทอรีโปรเจกต์เท่านั้น เพื่อจำกัดการเข้าถึงไฟล์

OpenAI ได้ตรวจสอบความปลอดภัยก่อนเปิดตัว และมี red-teaming เฉพาะทางไซเบอร์ แต่ควรตรวจสอบ diff ทุกครั้งก่อน deploy

เวลาไหนควรอัปเกรดจากฟรี

การเข้าถึงแบบ Free/Go จะหมดอายุในอนาคต พิจารณาอัปเกรดหาก:

ใช้โควต้าหมด: งานจริงจัง ควรไป Plus หรือ Pro
ต้องการ API ตรง: ภาระงานเกินขีดจำกัด CLI ดู คู่มือ API ของ GPT-5.5
ต้องการ seat-level billing: ทีมขนาดใหญ่ ดู รายละเอียดราคา

โมเดลพื้นฐานเหมือนเดิม เปลี่ยนแค่ billing และอินเทอร์เฟซ

คำถามที่พบบ่อย (FAQ)

Codex สามารถรัน GPT-5.5 Pro ได้หรือไม่?

ตอนนี้ Pro ยังไม่เปิดใน Codex CLI ใช้ GPT-5.5 มาตรฐานเท่านั้น

ใช้ Codex โดยไม่มีบัญชี ChatGPT ได้หรือไม่?

ไม่ได้ ต้องลงชื่อเข้าใช้ ChatGPT หรือใช้ OpenAI API key

Free และ Go จะใช้งานได้นานแค่ไหน?

OpenAI ระบุว่า "จำกัดเวลา" อาจไม่กี่สัปดาห์ถึงเดือน ควรวางแผนอัปเกรด

Codex ทำงานแบบออฟไลน์ได้หรือไม่?

ไม่ได้ ทุกคำสั่งต้องเชื่อมต่อกับ OpenAI

แตกต่างจากเว็บแอป ChatGPT อย่างไร?

Codex ทำงานในเทอร์มินัล มีสิทธิ์เข้าถึงระบบไฟล์, เชลล์, และ context ของ repo เว็บแอปไม่มีสิ่งเหล่านี้

วิธีใช้ GPT-5.5 API ฟรี

Thanawat Wongchai — Fri, 24 Apr 2026 02:18:56 +0000

GPT-5.5 เปิดตัวเมื่อวันที่ 23 เมษายน 2026 โดยมีการจำกัดการใช้งานฟรีสำหรับบริการส่วนใหญ่ เช่น Plus, Pro, Business และ Enterprise ใน ChatGPT รวมถึงโทเค็น API ที่ต้องชำระเงิน แต่ปัจจุบันยังมี 3 เส้นทางฟรีสำหรับใช้งาน GPT-5.5 หากคุณยอมรับข้อจำกัดด้านอัตราและวันหมดอายุได้ สามารถใช้งาน GPT-5.5 จริงโดยไม่ต้องเพิ่มวิธีการชำระเงิน

ทดลองใช้ Apidog วันนี้

บทความนี้สรุปเส้นทางฟรีแต่ละแบบ พร้อมแนะแนวการเลือกใช้งานให้เหมาะสมกับกรณีต่างๆ และวิธีเตรียมคอลเลกชันที่พร้อมใช้งานจริงใน Apidog เพื่อเปลี่ยนผ่านจากใช้งานฟรีเป็นแบบชำระเงินได้อย่างราบรื่น

สรุปโดยย่อ (TL;DR)

Codex CLI บน ChatGPT Free หรือ Go — เข้าถึง GPT-5.5 ฟรีชั่วคราวผ่าน CLI ไม่ต้องใช้บัตรเครดิต ใช้งานได้ทันที
เครดิตทดลองของ OpenAI สำหรับบัญชี API ใหม่ — ได้เครดิตเริ่มต้นสำหรับคีย์แรก ใช้งาน GPT-5.5 จริงได้เมื่อ Responses API เปิดตัว
OpenRouter และบริการรวม API ฟรี — เกตเวย์บุคคลที่สามที่บางครั้งให้โควตาฟรีสำหรับโมเดลใหม่ๆ หลังเปิดตัวไม่นาน
แต่ละเส้นทางมีข้อจำกัด แนะนำให้เปลี่ยนเป็นแบบชำระเงินหากต้องใช้งานจริงต่อเนื่อง

เส้นทางที่ 1: Codex CLI (เส้นทางฟรีที่ใช้งานได้จริงที่สุด)

OpenAI ผสาน Codex เข้ากับทุกแผน ChatGPT (ทั้ง Free และ Go) ชั่วคราว Codex เปิดเผย GPT-5.5 โดยใช้การลงชื่อเข้าใช้ ChatGPT แทน API Key คุณใช้บัญชีฟรี เรียก CLI และโมเดลจะตอบโดยใช้หน้าต่างโทเค็น 400K

การติดตั้ง

npm install -g @openai/codex
# หรือ
brew install codex

ตรวจสอบเวอร์ชัน:

codex --version

การยืนยันตัวตน

รัน codex ครั้งแรกเพื่อเข้าสู่ OAuth:

codex login --device-auth

ระบบจะให้ URL และรหัสสำหรับยืนยันบนเครื่องอื่น ไม่ต้องใช้ API Key

เลือกรุ่นโมเดล

ในเซสชัน Codex:

/model gpt-5.5

หรือเริ่ม CLI ด้วย flag:

codex --model gpt-5.5

ตรวจสอบโควตาที่เหลือด้วย /status โควต้า Free/Go จำกัดกว่าชำระเงิน แต่เพียงพอสำหรับการสร้างต้นแบบ

สิ่งที่ได้และข้อจำกัด

ได้ใช้ GPT-5.5 จริง บริบท 400K ใช้ CLI อ่านไฟล์ เรียกคำสั่งเทอร์มินัล แก้ไข repo ได้
ไม่ได้ API key โดยตรง ใช้ผ่าน Codex CLI เท่านั้น
การเข้าถึง Codex Free และ Go เป็นแบบ “เวลาจำกัด” ควรวางโครงสร้างโค้ดให้เปลี่ยนโมเดลหรือ API ได้ง่ายเมื่อหมดช่วงทดลอง

ดูคู่มือเต็ม: คู่มือการใช้งาน GPT-5.5 ฟรีกับ Codex

เส้นทางที่ 2: เครดิตทดลองของ OpenAI สำหรับบัญชี API ใหม่

บัญชี OpenAI ใหม่จะได้รับเครดิตทดลอง (เช่น 5 ดอลลาร์ใน 90 วันแรก) เมื่อ GPT-5.5 API เปิดตัว สามารถใช้เครดิตนี้เรียก gpt-5.5 ได้

วิธีรับสิทธิ์

สมัครบัญชีใหม่ที่ platform.openai.com (ใช้อีเมลที่ไม่เคยลงทะเบียน)
ยืนยันเบอร์โทรศัพท์
สร้าง API Key ภายใต้องค์กรทดลอง
ตรวจสอบแดชบอร์ดการใช้งานและวันหมดอายุ

ปริมาณการใช้งานที่ได้

เครดิต $5 ใช้ได้ ~1 ล้านโทเค็นอินพุต หรือ ~160K โทเค็นเอาต์พุต
เหมาะกับทดสอบต้นแบบ, เปรียบเทียบเวิร์กโฟลว์, ตรวจสอบวงจรเอเจนต์ขนาดเล็ก

ประหยัดเครดิต:

ใช้ Batch API (ค่าบริการ 50% ของอัตรามาตรฐาน)
ตั้งค่า reasoning.effort เป็น low ถ้าไม่ต้องการวิเคราะห์ลึก

ข้อควรระวัง: เครดิตทดลองหมดแล้วจะไม่ต่ออายุอัตโนมัติ และบัญชีใหม่ที่ข้อมูลซ้ำจะไม่ได้เครดิตซ้ำ

เส้นทางที่ 3: บริการรวม API ฟรี

เกตเวย์บุคคลที่สาม เช่น OpenRouter, Together, Groq บางครั้งให้โควตาฟรีโมเดลใหม่ๆ ให้ตรวจสอบความพร้อมก่อนใช้งาน

ขั้นตอนใช้งาน

สมัคร/ยืนยันอีเมลบนบริการรวม API
รับ API Key
เปลี่ยน base URL ใน SDK เป็นของบริการนั้นๆ
เปลี่ยนชื่อโมเดลเป็นของบริการ เช่น openai/gpt-5.5

ตัวอย่าง Python:

from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="sk-or-v1-...",
)

response = client.chat.completions.create(
    model="openai/gpt-5.5",
    messages=[{"role": "user", "content": "Explain the Responses API in two paragraphs."}],
)

print(response.choices[0].message.content)

ข้อควรระวัง: โควตาฟรีจำกัด, อาจถูกปิดเมื่อหมด หรือเมื่อโมเดลถูกนำออกจากระดับฟรี

คุณควรเลือกเส้นทางฟรีเส้นทางใด?

กรณีการใช้งาน	เส้นทางฟรีที่ดีที่สุด
ผู้ช่วยเขียนโค้ดบน Terminal	Codex CLI (เส้นทางที่ 1)
การทดลอง Python หรือ Node อย่างรวดเร็ว	เครดิตทดลอง (เส้นทางที่ 2)
การทดสอบจากแอปที่โฮสต์	บริการรวม API (เส้นทางที่ 3)
การเปรียบเทียบ GPT-5.5 กับ GPT-5.4 ด้วยพรอมต์จริง	เครดิตทดลอง + คอลเลกชัน Apidog
การวิจัยแบบครั้งเดียว "สิ่งนี้ตอบคำถามของฉันได้หรือไม่"	ChatGPT Plus (ไม่ฟรี แต่ถูกสุดต่อชั่วโมง)

สำหรับงานจริงหรืองาน production เส้นทางฟรีจะถึงขีดจำกัดเร็ว จุดเด่นคือได้เรียนรู้ pattern คำขอและการปรับแต่ง prompt ก่อนใช้โทเค็นชำระเงิน

สร้างรูปแบบคำขอไว้ล่วงหน้าใน Apidog

วิธีเปลี่ยนผ่านจาก “ทดลองใช้ฟรี” ไป “คีย์ใช้งานจริง” โดยไม่ต้องแก้โค้ด คือสร้างคำขอเดียวแล้วเก็บคอลเลกชันควบคุมเวอร์ชัน

ใน Apidog:

สร้างคอลเลกชัน เพิ่มคำขอ POST https://api.openai.com/v1/responses
ตั้งค่าส่วนหัว Authentication เป็นตัวแปรสภาพแวดล้อม สลับคีย์โดยไม่แก้เนื้อหา
บันทึกตัวอย่างการตอบกลับ ให้ dev อื่นใช้ mock ได้
โคลนคอลเลกชันสำหรับบริการรวม API เปลี่ยน baseUrl เป็น OpenRouter และเปลี่ยนชื่อโมเดล

เมื่อหมดช่วงทดลองหรืออัปเกรดแผน เพียงสลับตัวแปรสภาพแวดล้อม คอลเลกชันเดิมก็ยังใช้ต่อได้ ดู คำแนะนำการใช้งาน Apidog ใน VS Code สำหรับการใช้งานใน Cursor หรือ Claude Code

ข้อจำกัดของเส้นทางฟรีที่ควรวางแผน

ข้อจำกัดอัตราตามโหลด: Codex Free/Go ช้าลงเมื่อมีผู้ใช้สูงสุด
เครดิตทดลองไม่สะสม: สมัครใหม่ด้วยข้อมูลซ้ำไม่ได้เครดิตทดลองอีก
GPT-5.5 Pro ไม่มีในบริการฟรี: Pro ต้องชำระเงินเสมอ
โหมดคิดวิเคราะห์ใช้งบมาก: เส้นทางฟรีแนะนำตั้ง reasoning.effort เป็น low
ช่วงเวลาฟรีชั่วคราว: Codex Free/Go เปิดให้ใช้ฟรี “เวลาจำกัด” อ้างอิง ประกาศ OpenAI

ต้นแบบระดับฟรีที่สมจริง

ขั้นตอนสำหรับใช้โควตาฟรีให้เกิดประโยชน์สูงสุด:

เลือก task ที่ทีมใช้งานจริง เช่น รายงาน ตรวจโค้ด หรือสรุปงานวิจัย
รันทดสอบ 10 ตัวอย่างผ่าน GPT-5.4 บนเครื่องมือเดิม
รันทดสอบเดิมผ่าน GPT-5.5 บน Codex CLI หรือเครดิตทดลอง
เปรียบเทียบผลลัพธ์และต้นทุนโทเค็นแบบ side-by-side
ตัดสินใจว่าคุ้มค่าต่อการอัปเกรดหรือไม่

กิจกรรมนี้ใช้เวลาครึ่งวันแต่ให้ข้อมูลจริงสำหรับตัดสินใจในเดือนแรกของการใช้งาน production

คำถามที่พบบ่อย (FAQ)

การทดลองใช้ Codex Free และ Go เป็นถาวรไหม?

ไม่ใช่ ประกาศของ OpenAI ระบุว่าเป็น "เวลาจำกัด" คาดว่าหมดสิทธิ์ในไม่กี่เดือนหลังเปิดตัว

ChatGPT Free มี GPT-5.5 ในเบราว์เซอร์หรือไม่?

ไม่ ChatGPT Free ใช้ GPT-5.3 GPT-5.5 ต้อง Plus ขึ้นไป

รัน GPT-5.5 บน Hugging Face หรือ Ollama ฟรีได้หรือไม่?

ไม่ได้ GPT-5.5 เป็นโมเดลปิด ใช้งานได้เฉพาะบน OpenAI หรือ Codex CLI ที่ห่อหุ้มเท่านั้น

มีส่วนลดสำหรับนักเรียนหรือไม่?

OpenAI เคยให้ส่วนลดสำหรับอีเมล .edu และเครดิตทดลองสูงขึ้น ดู หน้าการศึกษาของ OpenAI สำหรับรายละเอียดล่าสุด

เปลี่ยนจากฟรีเป็นชำระเงินโดยไม่แก้โค้ดได้อย่างไร?

ใช้ตัวแปรสภาพแวดล้อมเช่น OPENAI_API_KEY และ OPENAI_BASE_URL สลับค่าตอนหมดช่วงทดลอง ดู คู่มือ GPT-5.5 API แนะนำให้ใช้คีย์ที่จำกัดขอบเขตโปรเจกต์

GPT-5.5 คืออะไร? โมเดลใหม่ล่าสุดจาก OpenAI ที่คุณต้องรู้

Thanawat Wongchai — Fri, 24 Apr 2026 01:52:52 +0000

OpenAI เปิดตัว GPT-5.5 เมื่อวันที่ 23 เมษายน 2026 เพียงหกสัปดาห์หลังจาก GPT-5.4 บริษัทเรียกรุ่นนี้ว่า “ปัญญาประเภทใหม่สำหรับงานจริง” หรือที่รู้จักในชื่อ “Spud” โมเดลนี้ถูกออกแบบมาสำหรับการเขียนโค้ดหลายขั้นตอน งานคอมพิวเตอร์ และการวิจัยเชิงลึก ปัจจุบันใช้งานได้ใน ChatGPT และ Codex โดย API จะเปิดตัวเร็วๆ นี้

ทดลองใช้ Apidog วันนี้

หากคุณกำลังตัดสินใจว่าจะอัปเกรดเป็น GPT-5.5 หรือไม่ คู่มือนี้จะสรุปให้ครบ: ความแตกต่างจาก 5.4, ผลลัพธ์ benchmark, วิธีใช้งานทันที และข้อควรระวังที่นักพัฒนาควรรู้

สำหรับนักพัฒนาสาย hands-on ดูลิงก์คู่มือเฉพาะทางต่อไปนี้:

หากต้องการเตรียม workflow รอ API เปิดตัว ดาวน์โหลด Apidog และสร้างคอลเลกชันไว้ล่วงหน้าได้ทันที

สรุป (TL;DR)

GPT-5.5: โมเดลสำหรับการเขียนโค้ดและ reasoning ชั้นนำของ OpenAI เปิดตัว 23 เม.ย. 2026
คะแนน 88.7% SWE-bench, 92.4% MMLU, ลดอัตรา hallucination 60% เทียบกับ 5.4
มี 3 รุ่น: มาตรฐาน, Thinking (reasoning เพิ่ม), Pro (ความแม่นยำสูงสุด)
ใช้งานได้ใน ChatGPT Plus, Pro, Business, Enterprise, Edu และ Codex ทุกแผน (Free/Go ทดลองใช้ชั่วคราว)
API ยังเปิดแบบจำกัด ใช้ผ่าน Codex CLI ได้ก่อน ส่วน Responses และ Chat Completions รอประกาศ
ราคา API $5/ล้านโทเค็นอินพุต, $30/ล้านโทเค็นเอาต์พุต (แพงกว่า 5.4 สองเท่า แต่ใช้โทเค็นน้อยลง)

GPT-5.5 คืออะไรจริงๆ

GPT-5.5 คือโมเดลระดับสูงสุดในสาย GPT-5 ของ OpenAI (รหัส “Spud” ในโพสต์ทีเซอร์) เหนือกว่า GPT-5.4, GPT-5.4-mini, และ 5.3 เดิม

3 รุ่นย่อยที่แยกการใช้งาน:

GPT-5.5 (มาตรฐาน): เร็ว, เฉียบคม, ใช้โทเค็นน้อย เหมาะกับงานส่วนใหญ่
GPT-5.5 Thinking: reasoning ขยาย, เหมาะกับสเปรดชีตซับซ้อน, สรุปวิจัย, ดีบักหลายไฟล์ (จำกัด ~3,000 ข้อความ/สัปดาห์ ใน ChatGPT)
GPT-5.5 Pro: ความแม่นยำสูงสุด, สำหรับงาน critical เฉพาะ Pro/Business/Enterprise

โมเดลนี้ถูกฝึกให้วางแผน เลือกเครื่องมือ ตรวจสอบผลลัพธ์เองก่อนส่งออก ลด prompt ที่ต้องเขียน, ลดข้อผิดพลาดในตาราง, กล้าหยุดถามเพื่อความชัดเจนมากกว่าทายมั่ว

อะไรเปลี่ยนจาก GPT-5.4

อัปเกรดนี้โฟกัสที่คุณสมบัติสำคัญและ benchmark:

ความสามารถ	GPT-5.4	GPT-5.5
SWE-bench	~74%	88.7%
MMLU	91.1%	92.4%
อัตรา hallucination	ค่าพื้นฐาน	−60%
หน้าต่าง context (API)	1.05M	1M (Codex: 400K)
ราคาอินพุต API	$2.50/M	$5.00/M
ราคาเอาต์พุต API	$15.00/M	$30.00/M
การใช้งานคอมพิวเตอร์	ยังไม่ production	ระดับ production
multistep toolchain	single-shot	auto loop เต็มรูปแบบ

จุดเด่น: SWE-bench เพิ่มเป็น 88.7% หมายถึงโมเดลแก้ issue จริงบน GitHub ได้ระดับ “วิศวกรอาวุโส” (benchmark) แต่ควรทดสอบกับ codebase จริงของคุณก่อนตัดสินใจเปลี่ยน

API แพงขึ้นสองเท่า แต่ OpenAI อ้างว่าประสิทธิภาพโทเค็นดีกว่า ทดสอบโดย The Decoder พบต้นทุนสุทธิเพิ่มราว 20% หากวัดจากโทเค็นที่ใช้จริง

จุดแข็งของ GPT-5.5

สี่งานที่ GPT-5.5 เหมาะสมที่สุด:

Agentic coding: อ่าน repo, เปิดไฟล์, รัน test, วนซ้ำ — ใช้กับ Codex หรือ CLI
Computer control: ขับ browser/terminal, กรอกฟอร์ม, ดึง structured data, กู้จาก error
Deep research: reasoning chain ยาว, ค้นหาเว็บ, สรุปแหล่งข้อมูลขัดแย้ง (Thinking โหมดเหมาะสุด)
Document/spreadsheet generation: วางเลย์เอาต์ดี, สูตรถูกต้อง, สไลด์สะอาด

ไม่เหมาะกับ: งาน bulk classification, retrieval, สรุปขนาดใหญ่ — 5.4-mini หรือ 5.3 ยังคุ้มกว่าด้านต้นทุน

ความพร้อมใช้งาน

สถานะวันที่ 23 เม.ย. 2026:

แพลตฟอร์ม	แผน	การเข้าถึง
ChatGPT	ฟรี/Go	GPT-5.3 เท่านั้น
ChatGPT	Plus	GPT-5.5 มาตรฐาน + Thinking (3,000/สัปดาห์)
ChatGPT	Pro/Business/Enterprise/Edu	มาตรฐาน + Thinking + Pro
Codex	ทุกแผน	GPT-5.5 (context 400K); Free/Go ทดลองใช้ชั่วคราว
API	Responses/Chat Completions	รอเปิดทั่วไป

นักพัฒนาสามารถใช้ GPT-5.5 ผ่าน Codex CLI ได้ทันทีโดยไม่ต้องรอ API key

ราคาในบรรทัดเดียว

GPT-5.5 API: $5 / ล้านโทเค็นอินพุต, $30 / ล้านโทเค็นเอาต์พุต
GPT-5.5 Pro API: $30 / ล้านอินพุต, $180 / ล้านเอาต์พุต (ราคาเท่า 5.4 Pro)
Batch/Flex: ครึ่งราคา standard
Priority: 2.5x standard
Codex CLI: ฟรีใน Plus, Pro, Business, Enterprise, Edu, Go; ทดลองจำกัดใน Free

ดูรายละเอียดและประมาณการต้นทุนงานจริงใน บทความราคา GPT-5.5

วิธีทดลองใช้ทันที

ChatGPT แผนจ่ายเงิน เลือก GPT-5.5 ที่ dropdown โมเดล
ติดตั้ง Codex CLI
```
npm install -g @openai/codex
# หรือ
brew install codex
codex
```
ลงชื่อเข้าใช้ด้วยบัญชี ChatGPT แล้วใช้ /model gpt-5.5 เพื่อเปลี่ยนโมเดล Free/Go ใช้ได้ในช่วงทดลอง (ดู คู่มือ Codex ฟรี)
เตรียม workflow รอ API API จะตามมาเร็วๆ นี้ เตรียมคอลเลกชันใน Apidog ได้เลย ดู คู่มือ API สำหรับ request format ที่คาดว่าจะใช้

ความปลอดภัยและ Red-teaming

OpenAI ทดสอบ GPT-5.5 กับบุคคลที่สามเพื่อรับรองด้านความปลอดภัยไซเบอร์และไบโอ โมเดลแต่ละเวอร์ชันมีมาตรการป้องกันใหม่ โดยเฉพาะพฤติกรรมปฏิเสธโค้ดสองวัตถุประสงค์และการเปิด API จะขึ้นกับมาตรการป้องกันที่เข้มงวดขึ้น ถ้าคุณทำระบบที่ end user ใช้เบราว์เซอร์หรือ automation interface วางแผนสำหรับ policy ที่เข้มกว่า 5.4

ควรเปลี่ยนไปใช้หรือไม่?

รันเอเจนต์เขียนโค้ด — เปลี่ยนเลย ประสิทธิภาพจะเห็นชัดและ Codex พร้อมแล้ว
รัน inference ปริมาณมาก — ใช้ 5.4-mini เป็น default, 5.5 เฉพาะงานยาก
งาน consumer-facing — รอ API เปิด ทดสอบ A/B ดูผลและต้นทุนจริง

ขั้นตอนตัดสินใจและประมาณการต้นทุน: รายละเอียดราคา

คำถามที่พบบ่อย

GPT-5.5 API ใช้ได้หรือยัง? ยัง API key ตรงยังไม่เปิด (ณ 23 เม.ย. 2026) แต่ใช้ผ่าน Codex CLI ได้หลัง login ChatGPT

Context window เท่าไหร่? 1M token สำหรับ ChatGPT/API, Codex CLI คือ 400K token ทุกแผน

Thinking ต่างกับ Pro ยังไง? Thinking = reasoning เพิ่มบน standard, Pro = โมเดลแยก มีความแม่นยำสูงสุด (มีเฉพาะ Pro/Business/Enterprise)

GPT-5.5 ฟรีไหม? ChatGPT ต้องจ่ายรายเดือน, Codex CLI ฟรีช่วงทดลองใน Free/Go อ่านคู่มือฟรี

5.4 ยังใช้ได้ไหม? ใช้ได้และถูกกว่า ($2.50/$15 ต่อล้านโทเค็น) เหมาะกับ pipeline ที่ต้องคุมต้นทุน

วิธีใช้ Hy3 Preview API ฟรี

Thanawat Wongchai — Thu, 23 Apr 2026 10:48:29 +0000

Tencent ได้เปิดตัว Hy3 Preview ในวันที่ 22 เมษายน 2026 และภายในหนึ่งวัน OpenRouter ก็ได้จัดให้เป็นปลายทางที่ใช้งานได้ฟรีโดยสมบูรณ์ ไม่ต้องใช้บัตรเครดิต ไม่มีการคิดค่าโทเค็น ไม่ต้องทดลองใช้ คุณสามารถเรียกใช้โมเดล Mixture-of-Experts ขนาด 295B พารามิเตอร์ตัวเดียวกันที่ขับเคลื่อนแอป Yuanbao และผู้ช่วย CodeBuddy ของ Tencent ได้จากโค้ดของคุณเองตั้งแต่วันนี้ โดยไม่มีค่าใช้จ่าย

ทดลองใช้ Apidog วันนี้

คู่มือนี้แสดงวิธีการใช้ Hy3 Preview API ฟรีผ่าน OpenRouter, Hugging Face Space และ Hy3 repo ดั้งเดิม นอกจากนี้ยังครอบคลุมโหมดการให้เหตุผลที่ทำให้ Hy3 แตกต่างจากโมเดลเปิดส่วนใหญ่ในปี 2026 และวิธีทดสอบ API ภายใน Apidog โดยไม่ต้องเขียนสคริปต์ที่ใช้แล้วทิ้ง

หากคุณต้องการวิธีที่เร็วที่สุดในการรับคำตอบแรก ให้ข้ามไปที่หัวข้อ "ขั้นตอน: เรียกใช้ Hy3 Preview ฟรีบน OpenRouter"

สรุป (TL;DR)

Hy3 Preview ใช้งานได้ฟรีบน OpenRouter ภายใต้ Model ID tencent/hy3-preview:free โดยมีค่าใช้จ่ายอินพุต $0 และเอาต์พุต $0
เป็น โมเดล Mixture-of-Experts: พารามิเตอร์ทั้งหมด 295B, ทำงาน 21B, 192 experts พร้อมการกำหนดเส้นทางแบบ top-8 และ หน้าต่างบริบทขนาด 256K โทเค็น
มี สามโหมดการให้เหตุผล ในตัว: no_think สำหรับคำตอบที่รวดเร็ว, low และ high สำหรับ chain-of-thought agent และการเขียนโค้ด
ผลการทดสอบมาตรฐานแข็งแกร่งสำหรับ open-weights: SWE-bench Verified 74.4, Terminal-Bench 2.0 54.4, GPQA Diamond 87.2, MMLU 87.42
ใช้งานฟรีได้ 3 ทาง: OpenRouter free tier, Hugging Face Hy3-preview Space หรือ self-host vLLM ด้วย open weights
Apidog รองรับ OpenRouter endpoint โดยตรง เพราะ Hy3 ใช้ OpenAI Chat Completions schema; ส่งคำขอไปยัง OpenRouter ได้ทันที

Hy3 Preview คืออะไร?

Hy3 Preview คือการเปิดตัวโมเดลเรือธงจากทีมโมเดลพื้นฐาน Hunyuan ของ Tencent ปัจจุบันนำโดย Yao Shunyu (อดีต OpenAI) มุ่งเน้นการใช้งานด้าน agent และ reasoning เป็นพิเศษ แข่งขันกับ DeepSeek, Alibaba, Zhipu ในตลาดโมเดล open-weights ของจีน

ข้อมูลทางเทคนิคจาก model card อย่างเป็นทางการ เน้นการทำงานแบบ agent-first:

สถาปัตยกรรม: Mixture-of-Experts, 80 เลเยอร์บวกหนึ่งเลเยอร์ MTP, 64 attention heads + grouped-query attention
พารามิเตอร์: รวม 295B, ทำงาน 21B ต่อ forward pass
Experts: 192 ผู้เชี่ยวชาญ (top-8 routing ต่อโทเค็น)
บริบท: 256K โทเค็น (262,144 บน OpenRouter)
Tokenizer: คลังคำศัพท์ 120,832 รายการ BF16
ลิขสิทธิ์: Tencent Hy Community License, ใช้เชิงพาณิชย์ได้ตามเงื่อนไข

Hy3 โดดเด่นกว่าด้วยการฝึก agentic และโครงสร้าง RL สำหรับการใช้งานเครื่องมือหลายรอบ คะแนน SWE-bench, Terminal-Bench, WildClawBench นำหน้าหลายโมเดล MoE ขนาดใหญ่

สามวิธีใช้ Hy3 Preview ฟรี

มี 3 เส้นทาง ขึ้นกับว่าคุณต้องการ UI แชท, API หรือรันโมเดลเอง

เส้นทาง	คืออะไร	ฟรีหรือไม่?	เหมาะสำหรับ
OpenRouter `tencent/hy3-preview:free`	Hosted OpenAI-compatible API	ใช่, $0	การสร้าง agent, สคริปต์, ฟีเจอร์ backend
Hugging Face Space	การสาธิตแชทในเบราว์เซอร์	ใช่	ทดลอง/ทดสอบเร็ว
Self-hosted weights (vLLM / SGLang)	รัน open weights บน GPU	ฟรี (ค่า HW)	งาน sensitive, ปริมาณสูง

โดยทั่วไป เส้นทาง OpenRouter สั้นสุด เหมาะกับ developer ที่ต้องการ API พร้อมใช้งาน และ free tier เพียงพอสำหรับ prototyping

ขั้นตอน: เรียกใช้ Hy3 Preview ฟรีบน OpenRouter

สร้างบัญชี OpenRouter

สมัครที่ openrouter.ai ใช้อีเมล ไม่ต้องใช้บัตรเครดิตสำหรับ free-tier
สร้าง API key

ไปที่แดชบอร์ด OpenRouter เลือก "Keys" แล้วสร้างคีย์ใหม่ คัดลอกไปตั้งค่า environment:

   export OPENROUTER_API_KEY=sk-or-...

เปิดหน้าโมเดล ไปที่ Hy3 Preview ฟรีบน OpenRouter ตรวจสอบแบนเนอร์ว่า "Free" และดูสถิติการใช้งาน

ส่งคำขอแรกของคุณ ใช้ OpenAI Chat Completions schema ได้ทันที ตัวอย่างด้วย curl:

   curl https://openrouter.ai/api/v1/chat/completions \
     -H "Authorization: Bearer $OPENROUTER_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{
       "model": "tencent/hy3-preview:free",
       "messages": [
         {"role": "user", "content": "Explain the MoE routing decision inside a top-8 of 192 setup in 3 sentences."}
       ],
       "temperature": 0.9,
       "top_p": 1.0
     }'

เปิดใช้ Reasoning Mode ตามต้องการ ใส่พารามิเตอร์ reasoning เพื่อเปิด chain-of-thought:

   {
     "model": "tencent/hy3-preview:free",
     "messages": [
       {"role": "user", "content": "Plan, then write a Bash script that rotates daily log files older than 30 days into a dated archive folder."}
     ],
     "reasoning": {"effort": "high"}
   }

วนซ้ำ ส่งข้อความต่อใน thread เดียวกันเพื่อคง context (Hy3 รองรับ 256K tokens)

ฟรี, พลัส, และโฮสต์เอง: สิ่งที่แตกต่างกัน

ความสามารถ	OpenRouter ฟรี	OpenRouter แบบชำระเงิน	โฮสต์เอง (vLLM/SGLang)
ค่าใช้จ่ายต่อโทเค็น	$0	ตามผู้ให้บริการ	ค่าไฟ + GPU
Reasoning modes	`no_think`, `low`, `high`	เหมือนกัน	เหมือนกัน
บริบท	256K	256K	256K (ถ้า HW เอื้อ)
ปริมาณงาน	Shared pool	เฉพาะทาง	ตามคลัสเตอร์
อัตราจำกัด	Free-tier limit	ตามผู้ให้	ไม่มี
การเก็บข้อมูล	OpenRouter policy	ตามผู้ให้	อยู่บนฮาร์ดแวร์คุณ
Reasoning token visibility	ใช่	ใช่	ใช่

Free เหมาะสำหรับต้นแบบ, ประเมินมาตรฐาน หรือ agent ปริมาณต่ำ หากปริมาณสูง/latency สำคัญ ให้เลือกแบบชำระเงินหรือโฮสต์เอง

เคล็ดลับ Prompt และ Parameter เพื่อดึงประสิทธิภาพสูงสุดจาก Hy3

ปรับอุณหภูมิ (temperature) ให้เหมาะกับงาน

เริ่มที่ temperature=0.9, top_p=1.0 ลดเหลือ 0.3 สำหรับเอาต์พุตที่เน้นโครงสร้าง
ใช้ no_think เป็นค่าเริ่มต้น

เหมาะกับแชททั่วไป เปิด low/high เฉพาะเมื่อต้องการ reasoning หรือเขียนโค้ดหลายขั้น
ตั้งชื่อเครื่องมือใน system prompt

เพิ่มรายละเอียด tool ใน prompt เพื่อผลลัพธ์ที่แม่นยำยิ่งขึ้น โดยเฉพาะเมื่อใช้ agent
อ้างอิงโค้ดจริง

ใช้ context window 256K วางไฟล์โค้ดแทนการให้โมเดลจินตนาการ
รวมการแก้ไขหลายไฟล์

ส่งข้อมูลหลายไฟล์ในข้อความเดียว Hy3 ตอบสนองการแก้ไขแบบรวมได้ดี
ขอแผนก่อน

Prompt แบบ "วางแผนก่อนแล้วดำเนินการ" ได้ผลลัพธ์ที่แม่นกว่า one-shot

ข้อจำกัดที่ควรทราบก่อนนำไปใช้งานจริง

อัตราการจำกัด free-tier

Shared pool, หากโดน 429 ให้ retry ด้วย exponential backoff
โทเค็น reasoning นับเป็นเอาต์พุต

บน free-tier reasoning ฟรี แต่บนแบบชำระเงินจะถูกคิดค่าใช้จ่าย
ลิขสิทธิ์ไม่ใช่ Apache 2.0

ใช้เชิงพาณิชย์ได้ แต่ต้องอ่าน ลิขสิทธิ์ฉบับเต็มบน GitHub repo
หากโฮสต์เอง ต้องใช้ parser ที่ถูกต้อง

vLLM: --tool-call-parser hy_v3 / SGLang: --tool-call-parser hunyuan ไม่งั้นจะไม่ได้ผลลัพธ์แบบ structured
เน้นภาษาอังกฤษ/จีน

คะแนนสูงสุดใน C-Eval/CMMLU ภาษาอื่นรองรับผ่าน MMMLU แต่คุณภาพรองลงมา
ยังตามหลังโมเดลเรือธงสหรัฐฯ บางด้าน

HLE ยังต่ำกว่า OpenAI/Google DeepMind ใน reasoning ที่ยาก

เส้นทางด่วนสำหรับนักพัฒนา: Hy3 Preview บวก Apidog

เปิด Apidog

สร้างโปรเจกต์ใหม่ แล้วนำเข้า OpenAI Chat Completions OpenAPI spec
ตั้งค่า base URL

เป็น https://openrouter.ai/api/v1 และเพิ่มตัวแปร OPENROUTER_API_KEY
สร้างคำขอ

เรียก /chat/completions และระบุ "model": "tencent/hy3-preview:free"
Fork คำขอ

ทดสอบ reasoning mode ต่างๆ (no_think, low, high) เปรียบเทียบ latency และ output
บันทึก prompt template

ใช้ environment/variable system ของ Apidog เพื่อ reuse prompt, schema, user turn

หากคุณย้ายมาจาก Postman ดู คู่มือการทดสอบ API โดยไม่ต้องใช้ Postman ในปี 2026

หรือใช้งาน Apidog บน VS Code ได้ตาม คำแนะนำนี้

ทางเลือกฟรีเมื่อคุณถึงขีดจำกัด

Hugging Face Space

Hy3-preview Space เหมาะกับการทดลองแชทในเบราว์เซอร์
โมเดล open-weights จีนอื่นๆ

Qwen 3.5 Omni ของ Alibaba มี free tier และรองรับ multimodal
- ประกาศ Qwen 3.5 Omni
- คู่มือการใช้งาน Qwen 3.5 Omni Zhipu GLM 5V Turbo เป็นอีกทางเลือก free tier ใจกว้าง
- คู่มือ API GLM 5V Turbo

หากต้องการเปรียบเทียบจริง ดาวน์โหลด Apidog และตั้งค่า collection แยกต่อโมเดล เปรียบเทียบด้วย prompt เดียวกันจะเห็นความแตกต่างได้ชัดเจนกว่าดูจากตารางคะแนน

โฮสต์ Hy3 Preview เองด้วย vLLM

ถ้ามีฮาร์ดแวร์ สามารถรัน inference เองบนเครื่องได้

แนะนำใช้ vLLM, tensor parallel 8, เปิด multi-token prediction:

vllm serve tencent/Hy3-preview \
  --tensor-parallel-size 8 \
  --speculative-config.method mtp \
  --speculative-config.num_speculative_tokens 1 \
  --tool-call-parser hy_v3 \
  --reasoning-parser hy_v3 \
  --enable-auto-tool-choice \
  --served-model-name hy3-preview

หากใช้ SGLang: ใส่ --tool-call-parser hunyuan และ --reasoning-parser hunyuan

เมื่อตั้งเซิร์ฟเวอร์เสร็จ (เช่น http://localhost:8000/v1) SDK ใดๆ ของ OpenAI สามารถชี้มายังเซิร์ฟเวอร์นี้ เปลี่ยน base URL และ key เท่านั้น

ต้องใช้ GPU ระดับ H100 8 ตัว (BF16) สำหรับ full model รุ่นควอนไทซ์อาจมีในอนาคต

คำถามที่พบบ่อย (FAQ)

Hy3 Preview ฟรีจริงหรือ?

ใช่, OpenRouter ระบุ tencent/hy3-preview:free $0 ต่อล้านโทเค็นอินพุต และเอาต์พุต Reasoning token ฟรีบน free tier (แต่ยังนับในอัตราการจำกัด)

Hy3 Preview เปรียบเทียบกับ DeepSeek V3/Qwen 3 อย่างไร?

คะแนน SWE-bench Verified 74.4, Terminal-Bench 54.4 เทียบเท่าโมเดลจีนชั้นนำ Qwen 3/DeepSeek V3 เหมาะกับแชท, Hy3 เด่นที่ agent/tool use

Reasoning modes ของ Hy3 มีอะไรบ้าง?

no_think (ค่าเริ่มต้น)
low
high เปลี่ยนด้วยพารามิเตอร์ reasoning บน OpenRouter หรือ chat_template_kwargs={"reasoning_effort": "high"} (direct call)

ใช้ Hy3 Preview ในเชิงพาณิชย์ได้ไหม?

ได้ ภายใต้ Tencent Hy Community License (อ่าน ลิขสิทธิ์เต็ม ก่อนฝังใน production)

Free tier รองรับ context กี่ token?

256K tokens (OpenRouter 262,144) วางโค้ดเบสกลางๆ ได้ทั้ง repo

ทดสอบ Hy3 Preview โดยไม่เขียนโค้ดอย่างไร?

Hugging Face Space
หรือ config Apidog ชี้ไปที่ OpenRouter (base URL, API key, model name)