DEV Community: Thanawat Wongchai

วิธีใช้ Seedance 2.0 API ปี 2026

Thanawat Wongchai — Sat, 04 Apr 2026 13:09:52 +0000

สรุปสั้นๆ

API ของ Seedance 2.0 เปิดตัวเมื่อวันที่ 2 เมษายน 2026 ผ่าน Volcengine Ark คุณสามารถส่งงานสร้างวิดีโอด้วยคำขอ POST จากนั้นตรวจสอบสถานะ (poll) จากปลายทาง GET จนกว่าสถานะจะถึง "succeeded" API รองรับ Text-to-video, Image-to-video, การควบคุมเฟรมเริ่มต้นและเฟรมสุดท้าย, การอ้างอิงแบบหลากหลายสื่อ (multimodal references) และการสร้างเสียงแบบ native วิดีโอ 1080p ความยาว 5 วินาทีมีค่าใช้จ่ายประมาณ $0.93 ดาวน์โหลดวิดีโอภายใน 24 ชั่วโมง URL จะหมดอายุหลังจากนั้น

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

Hypereal AI

ลองใช้ Hypereal AI

บทนำ

เมื่อวันที่ 2 เมษายน 2026 แพลตฟอร์ม Volcengine Ark ของ ByteDance ได้เปิดตัว API อย่างเป็นทางการของ Seedance 2.0 ก่อนหน้านั้น วิธีเดียวในการสร้างวิดีโอ Seedance 2.0 คือผ่านเว็บคอนโซล หากคุณเคยเห็นบทเรียนที่แสดงการใช้งาน UI วิดีโอเหล่านั้นเขียนขึ้นสำหรับคอนโซลนี้ แต่คู่มือนี้จะครอบคลุม API จริงที่นักพัฒนาสามารถเรียกใช้ด้วยโปรแกรมได้

💡API ใช้รูปแบบงานแบบ asynchronous: POST เพื่อสร้างงาน, รับ ID ของงาน, จากนั้น poll ปลายทาง GET จนกว่างานจะเสร็จสิ้น รูปแบบนี้คุ้มค่าที่จะทดสอบแบบ end-to-end ก่อนที่คุณจะนำไปใช้งานจริง Test Scenarios ของ Apidog ช่วยให้คุณสามารถเชื่อมโยงการส่ง POST, ดึง ID ของงาน, วนซ้ำการ poll ด้วย GET และยืนยันว่าการตอบกลับสุดท้ายมี URL วิดีโอที่ถูกต้อง ดาวน์โหลด Apidog ฟรีเพื่อทำตามขั้นตอนการทดสอบในส่วน Apidog ด้านล่าง

บทความนี้ครอบคลุมประเภทอินพุตที่รองรับทั้งหมด, การคำนวณราคาจากจำนวนโทเค็นในการตอบกลับ และข้อผิดพลาดที่คุณอาจพบในการใช้งานจริง

Seedance 2.0 คืออะไร?

Seedance 2.0 คือโมเดลการสร้างวิดีโอจาก ByteDance บน Volcengine Ark ภายใต้ ID โมเดล doubao-seedance-2-0-260128 (มาตรฐาน) และ doubao-seedance-2-0-fast-260128 (เร็วกว่า คุณภาพต่ำกว่า)

ฟีเจอร์หลักเมื่อเทียบกับเวอร์ชัน 1.5:

รองรับ Text-to-video และ Image-to-video
กำหนดเฟรมแรกและเฟรมสุดท้าย (ใส่ภาพเริ่ม-จบ)
อินพุตอ้างอิงแบบหลากหลายสื่อ: รูป, วิดีโอ, เสียง
สร้างเสียง native (พูด, SFX, เพลง, ฯลฯ)
ซิงค์ปากมากกว่า 8 ภาษา
ควบคุมกล้องด้วย text prompt (dolly, tracking ฯลฯ)
เอาต์พุตสูงสุด 15 วินาที ถึง 2K

วิดีโอจะออกที่ 24 fps อัตราส่วน 1:1 ถึง 21:9 เลือกความละเอียดได้ขณะส่งคำขอ

มีอะไรเปลี่ยนแปลง: คู่มือเทียบกับ API อย่างเป็นทางการ

ก่อนหน้านี้ Seedance 2.0 ใช้งานได้เฉพาะผ่าน web console (ดู คู่มือเดือน ก.พ. 2026) ตอนนี้ API เปิดให้นักพัฒนารวม Seedance เข้ากับโปรแกรมหรือ workflow ของตัวเองได้โดยตรง

สิ่งที่ต้องมีก่อนใช้งาน

สมัครบัญชี Volcengine ที่ volcengine.com
เข้าคอนโซล Ark:

   https://console.volcengine.com/ark/region:ark+cn-beijing/apikey

สร้าง API Key แล้ว export เป็น env:

   export ARK_API_KEY="your-api-key-here"

ทุก API request ใส่ header:

   Authorization: Bearer YOUR_ARK_API_KEY

บัญชีใหม่ได้เครดิตทดลองใช้ฟรี (สร้างวิดีโอ 15 วินาทีที่ 1080p ได้ประมาณ 8 ครั้ง)

Text-to-video: คำขอแรกของคุณ

Base URL:

https://ark.cn-beijing.volces.com/api/v3

POST ไปยัง /v1/contents/generations/tasks

ตัวอย่าง cURL

curl -X POST "https://ark.cn-beijing.volces.com/api/v3/contents/generations/tasks" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $ARK_API_KEY" \
  -d '{
    "model": "doubao-seedance-2-0-260128",
    "content": [
      {
        "type": "text",
        "text": "A golden retriever running through a sunlit wheat field, wide tracking shot, cinematic"
      }
    ],
    "resolution": "1080p",
    "ratio": "16:9",
    "duration": 5,
    "watermark": false
  }'

Response:

{"id": "cgt-2025xxxxxxxx-xxxx"}

ตัวอย่าง Python (SDK อย่างเป็นทางการ)

ติดตั้ง SDK:

pip install volcenginesdkarkruntime

ส่งงาน:

import os
from volcenginesdkarkruntime import Ark

client = Ark(api_key=os.environ.get("ARK_API_KEY"))

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "A golden retriever running through a sunlit wheat field, wide tracking shot, cinematic"
        }
    ],
    resolution="1080p",
    ratio="16:9",
    duration=5,
    watermark=False,
)

print(resp.id)

เก็บ task ID ไว้สำหรับ polling สถานะ

รูปแบบงานแบบ Asynchronous: ส่ง, ตรวจสอบสถานะ, ดาวน์โหลด

งานสร้างวิดีโอจะมีสถานะดังนี้:

queued -> running -> succeeded
                -> failed
                -> expired
                -> cancelled

คุณต้อง poll GET จนกว่าสถานะจะเป็น succeeded

ตัวอย่างลูปตรวจสอบสถานะ Python

import os
import time
import requests
from volcenginesdkarkruntime import Ark

client = Ark(api_key=os.environ.get("ARK_API_KEY"))

# Step 1: submit
resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {"type": "text", "text": "Aerial shot of a mountain lake at sunrise, slow dolly forward"}
    ],
    resolution="1080p",
    ratio="16:9",
    duration=5,
    watermark=False,
)

task_id = resp.id
print(f"Task submitted: {task_id}")

# Step 2: poll with exponential backoff
wait = 10
while True:
    result = client.content_generation.tasks.get(task_id=task_id)
    status = result.status
    print(f"Status: {status}")

    if status == "succeeded":
        video_url = result.content.video_url
        print(f"Video URL: {video_url}")
        break
    elif status in ("failed", "expired", "cancelled"):
        print(f"Task ended with status: {status}")
        break

    time.sleep(wait)
    wait = min(wait * 2, 60)

# Step 3: download immediately
if status == "succeeded":
    response = requests.get(video_url, stream=True)
    with open("output.mp4", "wb") as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)
    print("Downloaded: output.mp4")

หมายเหตุ: ใช้ exponential backoff เพื่อลดการ poll ถี่เกินไป

Image-to-video (I2V): การสร้างแอนิเมชันจากภาพนิ่ง

เพิ่ม object "image_url" ใน content:

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "The woman slowly turns her head and smiles at the camera"
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/portrait.jpg"}
        }
    ],
    ratio="adaptive",
    duration=5,
    watermark=False,
)

ratio: "adaptive" จะใช้อัตราส่วนภาพของภาพต้นฉบับ
ภาพสูงสุด 30MB, 9 ภาพต่อคำขอ

เฟรมแรกและเฟรมสุดท้าย: ควบคุมจุดเริ่มต้นและจุดสิ้นสุด

ระบุภาพเฟรมแรกและเฟรมสุดท้ายใน content:

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "The flower blooms from bud to full open, macro lens, soft light"
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/flower-bud.jpg"}
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/flower-open.jpg"}
        }
    ],
    ratio="adaptive",
    duration=8,
    watermark=False,
)

ภาพลำดับ: เฟรมแรก, เฟรมสุดท้าย
ใช้ return_last_frame: true เพื่อขอภาพเฟรมสุดท้าย ส่งภาพนี้ไปยังคลิปถัดไปเพื่อเชื่อมวิดีโอหลายคลิป

การอ้างอิงแบบหลากหลายสื่อ: รวมรูป, วิดีโอ, เสียง

content อนุญาต:

{"type": "text", "text": "..."}
{"type": "image_url", "image_url": {"url": "..."}}
{"type": "video_url", "video_url": {"url": "..."}}
{"type": "audio_url", "audio_url": {"url": "..."}}

ข้อจำกัด:

รูป: สูงสุด 9 ภาพ (30MB/ภาพ)
วิดีโอ: สูงสุด 3 คลิป (2-15 วินาที, 50MB/คลิป)
เสียง: 3 ไฟล์ (MP3, 15MB/ไฟล์)

ตัวอย่าง:

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "Match the visual style of the reference clip and add the provided background audio"
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/style-reference.jpg"}
        },
        {
            "type": "video_url",
            "video_url": {"url": "https://example.com/motion-reference.mp4"}
        },
        {
            "type": "audio_url",
            "audio_url": {"url": "https://example.com/background-music.mp3"}
        }
    ],
    duration=10,
    ratio="16:9",
    watermark=False,
)

ถ้ามีวิดีโอ reference อัตราค่าบริการจะลดลง (ดูหัวข้อราคา)

การสร้างเสียงแบบ Native

ตั้งค่า generate_audio: true เพื่อให้ Seedance สร้างเสียงพร้อมวิดีโอ:

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "A street musician plays guitar outside a cafe in Paris, crowds passing by, city sounds"
        }
    ],
    resolution="1080p",
    ratio="16:9",
    duration=10,
    generate_audio=True,
    watermark=False,
)

รองรับพูด, SFX, เสียงบรรยากาศ, เพลง
ซิงค์ปากหลายภาษา
เพิ่มการใช้โทเค็นเล็กน้อย

การควบคุมความละเอียด, อัตราส่วนภาพ, ระยะเวลา

resolution: "480p", "720p", "1080p", "2K" (default "1080p")
ratio: "16:9", "9:16", "4:3", "3:4", "21:9", "1:1", "adaptive"
duration: 4-15 วินาที (default 5)

หมายเหตุ:

โมเดลแบบเร็ว (doubao-seedance-2-0-fast-260128) สร้างไวกว่าแต่คุณภาพต่ำกว่า ใช้สำหรับ prototyping

การอ่านค่าใช้จ่ายจาก Response

หลังงานสำเร็จ field usage จะบอกจำนวนโทเค็น:

{
  "usage": {
    "completion_tokens": 246840,
    "total_tokens": 246840
  }
}

ตัวอย่างอัตรา:

1080p 15 วินาที ~308,880 โทเค็น
1080p 5 วินาที ~102,960 โทเค็น
ราคาประมาณ $6.40 ต่อล้านโทเค็น (T2V/I2V), $3.90 ต่อล้านโทเค็น (V2V)
ตรวจสอบ field นี้ทุก response เพื่อ track ค่าใช้จ่าย

สำคัญ: ดาวน์โหลดวิดีโอภายใน 24 ชั่วโมง

video_url จะหมดอายุใน 24 ชั่วโมงหลังจากงานสำเร็จ
ดาวน์โหลดไฟล์ทันทีก่อนหมดอายุ
ประวัติงานสอบถามได้ 7 วัน แต่ไฟล์หายถ้าเลย 24 ชั่วโมง

วิธีทดสอบ Seedance API ด้วย Apidog

ด้วยโครงสร้าง async ของ API จำเป็นต้องทดสอบแบบหลายขั้นตอน

ขั้นตอนการตั้งค่า Test Scenario

สร้าง Test Scenario:
- ไปที่โมดูล Tests ของ Apidog
- ตั้งค่า env ตัวแปร ARK_API_KEY
เพิ่มคำขอ submit:
- POST ไปยัง https://ark.cn-beijing.volces.com/api/v3/contents/generations/tasks
- Header: Authorization: Bearer {{ARK_API_KEY}}
- Extract ตัวแปร $.id ลง env TASK_ID
เพิ่ม Wait:
- Wait 30 วินาทีหลัง submit
เพิ่ม GET poll ใน For loop:
- GET ไปยัง /tasks/{{TASK_ID}}
- Wait 10 วินาทีในแต่ละรอบ
- Break if $.status == "succeeded" หรือ "failed"
เพิ่ม Assertion:
- ตรวจสอบ $.status == "succeeded"
- ตรวจสอบว่า $.content.video_url มีค่า

สามารถนำเข้า cURL โดยตรงเข้าสู่ Apidog เพื่อสร้าง scenario เร็วขึ้น

รายละเอียดราคา: วิดีโอ 10 วินาทีมีค่าใช้จ่ายเท่าไหร่

ประเภทงาน	อัตรา (ต่อ 1 ล้านโทเค็น)
T2V / I2V ที่ 1080p	46 หยวน (~$6.40)
V2V (reference video)	28 หยวน (~$3.90)

ระยะเวลา	โทเค็นโดยประมาณ	ค่าใช้จ่าย (T2V/I2V)
5 วินาที	~103,000	~$0.93
10 วินาที	~206,000	~$1.32
15 วินาที	~309,000	~$1.97

บัญชีใหม่ได้เครดิตทดลองใช้ฟรี (1080p 15 วินาที ~8 คลิป)
ลด resolution ช่วยลดต้นทุน

ข้อผิดพลาดทั่วไปและการแก้ไข

429 Too Many Requests: ชน concurrency limit ใช้ exponential backoff (รอ 10s, 20s, ... สูงสุด 60s)
status: "failed": โมเดลสร้างไม่สำเร็จ ตรวจสอบ prompt, รูป หรือพารามิเตอร์
status: "expired": งานหมดอายุ ส่งใหม่เท่านั้น
403 on video_url: URL หมดอายุ ดาวน์โหลดไม่ทันใน 24 ชั่วโมง ต้องสร้างใหม่
Seed reproducibility: บันทึกค่า seed ไว้ถ้าต้องการ re-run ให้ได้ผลลัพธ์เดิม

บทสรุป

Seedance 2.0 API เปิดโอกาสให้คุณสร้างวิดีโอแบบ asynchronous ได้แบบโปรแกรม รองรับอินพุตหลากหลาย, สร้างเสียง native, ควบคุมเฟรมแรก/สุดท้าย และทดสอบ workflow ได้ครบถ้วนด้วย Apidog

ตั้งค่า Test Scenario ใน Apidog เพื่อป้องกันปัญหาจากการ poll, การดึงข้อมูล หรือ URL หมดอายุ ก่อนใช้งานจริง

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

Q: ความแตกต่าง doubao-seedance-2-0-260128 กับ doubao-seedance-2-0-fast-260128?

A: เวอร์ชันมาตรฐานเน้นคุณภาพสูง ใช้สำหรับ production. เวอร์ชัน fast เร็วกว่า เหมาะกับ prototyping

Q: ใช้ Seedance 2.0 นอกประเทศจีนได้ไหม?

A: ได้ API host ที่ปักกิ่ง อาจหน่วงขึ้น ตรวจสอบข้อจำกัดบัญชี Volcengine

Q: เชื่อมหลายคลิปให้เป็นวิดีโอยาวได้อย่างไร?

A: ใช้ return_last_frame: true เพื่อดึงเฟรมสุดท้ายมาเป็นเฟรมแรกของคลิปถัดไป แล้วนำคลิปมาต่อด้วย video editor

Q: Native audio มีค่าใช้จ่ายเพิ่มไหม?

A: ใช้โทเค็นเพิ่มขึ้นเล็กน้อยเพราะสร้างเสียงพร้อมวิดีโอ

Q: ตั้ง webhook แทน polling ได้ไหม?

A: ได้ ส่ง callback_url ใน submit API จะ POST ผลลัพธ์ไปที่ URL นั้นเมื่อเสร็จ

Q: ส่งรูปเกิน 9 รูปเป็นอย่างไร?

A: API ตีกลับ error 400 ลดจำนวนรูปใน content array ให้ไม่เกิน 9

Q: seed รับประกันผลลัพธ์เดิมหรือไม่?

A: ไม่ 100% แต่ถ้าพารามิเตอร์เหมือนเดิมและ server model ไม่เปลี่ยน จะใกล้เคียงที่สุด

Q: ติดตามค่าใช้จ่ายงานจำนวนมากอย่างไร?

A: อ่าน completion_tokens จากแต่ละ response คูณอัตราราคาตามประเภทงานแล้วเก็บ log เอง (API ไม่มี dashboard)

วิธีใช้ Grok Text to Video API ฉบับสมบูรณ์

Thanawat Wongchai — Fri, 03 Apr 2026 08:51:14 +0000

สรุปสั้นๆ

Grok text-to-video API สร้างวิดีโอจากข้อความ prompt ด้วยการเรียก POST /v1/videos/generations จะได้รับ request_id กลับมาทันที แล้วใช้ GET /v1/videos/{request_id} ตรวจสอบสถานะจนกว่าจะเป็น "done" โมเดลคือ grok-imagine-video เริ่มต้น $0.05/วินาที (480p) xAI Python SDK ช่วยทำ polling อัตโนมัติ

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

บทนำ

xAI สร้างวิดีโอ 1.2 พันล้านรายการในเดือนแรกหลังเปิดตัว Grok text-to-video API (28 มกราคม 2026) โมเดลนี้ติดอันดับหนึ่ง text-to-video ของ Artificial Analysis ในเดือนเดียวกัน โครงสร้างพื้นฐานรองรับปริมาณงานขนาดใหญ่แล้ว

คู่มือนี้ให้ขั้นตอนตั้งแต่สร้างคำขอแรก, ตรวจสอบผลลัพธ์, ปรับแต่งพารามิเตอร์, เขียน prompt ให้ดีขึ้น, ใช้รูปภาพอ้างอิง, ขยาย/แก้ไขวิดีโอ และเลือก text-to-video ให้เหมาะกับงานของคุณ

💡 API ทำงาน async: ส่วนหน้า (frontend) ไม่สามารถรอให้วิดีโอพร้อมก่อนแสดงผล คุณต้องใช้ polling flow เสมอ Smart Mock ของ Apidog ช่วยสร้าง mock endpoint ทั้ง generation และ polling เพื่อให้ dev frontend พัฒนา UI ได้แม้ backend ยังไม่เสร็จ ดาวน์โหลด Apidog ฟรีเพื่อทดสอบตามคู่มือนี้

Grok text-to-video API คืออะไร?

Grok text-to-video API อยู่ที่ https://api.x.ai ส่งข้อความ prompt แล้วโมเดล grok-imagine-video จะสร้างคลิปวิดีโอใหม่โดยไม่ต้องมีภาพต้นฉบับ

API ตัวนี้ทำงานร่วมกับ endpoint สร้างรูปภาพแบบ synchronous (POST /v1/images/generations, โมเดล grok-imagine-image, $0.02/ภาพ) และ endpoint ขยาย/แก้ไขวิดีโอ

text-to-video: ให้แค่ข้อความ prompt โมเดลสร้างฉาก, motion, สไตล์เอง
image-to-video: ให้รูปต้นฉบับ โมเดลทำให้ภาพนั้นเคลื่อนไหว

ดู คู่มือ Grok image-to-video API ถ้าคุณต้องการให้ภาพนิ่งเคลื่อนไหว

การสร้างวิดีโอจากข้อความ (async flow)

การสร้างวิดีโอใช้เวลาหลายวินาทีถึงนาที API จึงเป็น async:

ส่ง POST พร้อม prompt
ได้ request_id ทันที
วิดีโอถูกสร้างบนเซิร์ฟเวอร์
Poll ที่ GET endpoint ด้วย request_id
ได้ status เปลี่ยนเป็น "done" จะได้ URL วิดีโอ

หมายเหตุ: frontend ต้องแสดง loading state ระหว่างรอ

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

บัญชี xAI: สมัครที่ console.x.ai ต้องกรอกข้อมูล billing ก่อนสร้าง video ได้
API key: สร้างที่ API Keys ในคอนโซล xAI ส่งเป็น Bearer token ทุก request

ตั้งค่าเป็น env variable:

export XAI_API_KEY="your_api_key_here"

(เลือก) ติดตั้ง xAI Python SDK:

pip install xai-sdk

คำขอ text-to-video แรกของคุณ

Endpoint: POST https://api.x.ai/v1/videos/generations

จำเป็น: model, prompt

ตัวอย่าง curl

curl -X POST https://api.x.ai/v1/videos/generations \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "prompt": "A golden retriever running through autumn leaves in slow motion, cinematic lighting"
  }'

ผลลัพธ์:

{
  "request_id": "d97415a1-5796-b7ec-379f-4e6819e08fdf"
}

ตัวอย่าง Python (requests)

import requests
import os

API_KEY = os.environ["XAI_API_KEY"]
BASE_URL = "https://api.x.ai"

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

payload = {
    "model": "grok-imagine-video",
    "prompt": "A golden retriever running through autumn leaves in slow motion, cinematic lighting"
}

response = requests.post(
    f"{BASE_URL}/v1/videos/generations",
    headers=headers,
    json=payload
)

data = response.json()
request_id = data["request_id"]
print(f"Generation started. Request ID: {request_id}")

การตรวจสอบสถานะเพื่อรับผลลัพธ์วิดีโอ

เมื่อต้องการผลลัพธ์ ให้เรียก GET /v1/videos/{request_id} เรื่อยๆ จน status เป็น "done"

status ที่เป็นไปได้:

"processing": กำลังสร้าง
"done": เสร็จ มี URL วิดีโอ
"failed": ล้มเหลว

Polling Loop (Python)

import requests
import time
import os

API_KEY = os.environ["XAI_API_KEY"]
BASE_URL = "https://api.x.ai"

headers = {
    "Authorization": f"Bearer {API_KEY}"
}

def poll_video(request_id: str, interval: int = 5, max_attempts: int = 60) -> dict:
    url = f"{BASE_URL}/v1/videos/{request_id}"
    for attempt in range(max_attempts):
        response = requests.get(url, headers=headers)
        data = response.json()
        status = data.get("status")
        progress = data.get("progress", 0)
        print(f"Attempt {attempt + 1}: status={status}, progress={progress}%")
        if status == "done":
            return data
        elif status == "failed":
            raise RuntimeError(f"Video generation failed: {data}")
        time.sleep(interval)
    raise TimeoutError(f"Video not ready after {max_attempts} attempts")

def generate_video(prompt: str) -> str:
    response = requests.post(
        f"{BASE_URL}/v1/videos/generations",
        headers={**headers, "Content-Type": "application/json"},
        json={"model": "grok-imagine-video", "prompt": prompt}
    )
    request_id = response.json()["request_id"]
    print(f"Request ID: {request_id}")
    result = poll_video(request_id)
    video_url = result["video"]["url"]
    print(f"Video ready: {video_url}")
    return video_url

video_url = generate_video(
    "A timelapse of a city skyline at sunset transitioning to night, aerial view"
)

ตัวอย่างผลลัพธ์เมื่อ status = done:

{
  "status": "done",
  "video": {
    "url": "https://vidgen.x.ai/....mp4",
    "duration": 8,
    "respect_moderation": true
  },
  "progress": 100,
  "usage": {
    "cost_in_usd_ticks": 500000000
  }
}

การใช้ xAI Python SDK

SDK จะ handle polling ให้อัตโนมัติ:

from xai_sdk import Client
import os

client = Client(api_key=os.environ["XAI_API_KEY"])

result = client.video.generate(
    model="grok-imagine-video",
    prompt="A golden retriever running through autumn leaves in slow motion",
    duration=8,
    resolution="720p",
    aspect_ratio="16:9"
)

print(f"Video URL: {result.video.url}")
print(f"Duration: {result.video.duration}s")

ใช้ SDK สำหรับการพัฒนาเร็ว ถ้าต้องการควบคุม retry หรือ polling interval ใช้ raw HTTP

การเขียน prompt ที่มีประสิทธิภาพสำหรับวิดีโอ

อธิบายฉากชัดเจน: บอกตัวแบบ+ฉากหลัง
การเคลื่อนไหว: เจาะจงว่ากล้องหรือ object เคลื่อนไหวยังไง
สไตล์กล้อง: เช่น "close-up", "drone shot"
แสง/บรรยากาศ: "golden hour", "overcast", ฯลฯ
อ้างอิงสไตล์: "cinematic", "anime", ผสมหลายสไตล์ได้
prompt โครงสร้างดี:

  A lone astronaut floats past the International Space Station,
  tether drifting behind them. The camera tracks slowly
  alongside, showing Earth below. Cinematic, IMAX quality,
  warm sunrise light reflecting off the visor.

การควบคุมความละเอียด, ระยะเวลา, อัตราส่วนภาพ

duration: 1-15 วินาที (default 6s)
resolution: "480p" (default), "720p"
aspect_ratio: "16:9", "9:16", "1:1", "4:3", "3:4", "3:2", "2:3"

อัตราส่วน	เหมาะสำหรับ
16:9	เดสก์ท็อป, YouTube (default)
9:16	TikTok, IG Reels, มือถือ
1:1	IG feed, social cards
4:3	วิดีโอคลาสสิก, นำเสนอ
3:4	มือถือแนวตั้ง
3:2	ภาพถ่ายมาตรฐาน
2:3	ถ่ายภาพบุคคล

ตัวอย่าง curl แบบเต็ม

curl -X POST https://api.x.ai/v1/videos/generations \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "prompt": "A coastal town at dawn, waves breaking gently on a rocky shore",
    "duration": 10,
    "resolution": "720p",
    "aspect_ratio": "16:9"
  }'

การใช้รูปภาพอ้างอิงเพื่อกำหนดสไตล์วิดีโอ

ส่ง reference_images (array URLs สูงสุด 7 ภาพ) เพื่อชี้นำสไตล์และโทนภาพ:

{
  "model": "grok-imagine-video",
  "prompt": "A coastal town at dawn, waves breaking gently on a rocky shore",
  "reference_images": [
    {"url": "https://example.com/my-style-reference.jpg"},
    {"url": "https://example.com/color-palette-reference.jpg"}
  ]
}

ภาพควรสอดคล้องกันเพื่อผลลัพธ์ดีที่สุด
ต่างจาก image-to-video: prompt ยังขับเคลื่อนฉากหลัก

การขยายและแก้ไขวิดีโอที่สร้างขึ้น

ขยายวิดีโอ: POST /v1/videos/extensions ส่ง request_id + prompt ใหม่ เพื่อเพิ่มฟุตเทจต่อท้าย (ใช้ทำคลิปยาว >15 วินาที)
แก้ไขวิดีโอ: POST /v1/videos/edits ส่ง request_id + prompt เพื่อเปลี่ยนสไตล์/ฉาก/เอฟเฟกต์

ทั้งคู่ใช้ polling แบบเดียวกับ main endpoint

การอ่านค่าใช้จ่ายจาก API

ผลลัพธ์ที่สมบูรณ์จะมี usage:

"usage": {
  "cost_in_usd_ticks": 500000000
}

หารด้วย 10,000,000 เพื่อแปลงเป็นดอลลาร์:

cost_in_usd = result["usage"]["cost_in_usd_ticks"] / 10_000_000
print(f"Cost: ${cost_in_usd:.4f}")
# Output: Cost: $0.0500

ตารางราคา

ความละเอียด	ราคาต่อวินาที	คลิป 10 วินาที
480p	$0.05	$0.50
720p	$0.07	$0.70

บันทึก cost_in_usd_ticks จากทุก polling ที่สำเร็จเพื่อ track ต้นทุน

วิธีทดสอบ Grok video API ของคุณด้วย Apidog

async polling flow ทำให้ทดสอบ frontend ยาก เพราะต้อง handle สถานะ loading/success/error โดยไม่เปลืองเครดิตจริง Smart Mock ของ Apidog ช่วยแก้ปัญหานี้

กรณี 1: Smart Mock สำหรับ dev frontend

จำลอง generation endpoint:
- สร้าง POST /v1/videos/generations กำหนด response schema มี request_id
- Smart Mock ตอบกลับ UUID ปลอม
- ตัวอย่าง:
```
{
  "request_id": "d97415a1-5796-b7ec-379f-4e6819e08fdf"
}
```

จำลอง poll endpoint:

สร้าง GET /v1/videos/{request_id} กำหนด response schema เต็ม
ตั้ง Custom Mock response ส่ง "status": "done" + URL วิดีโอเทียม

{
  "status": "done",
  "video": {
    "url": "https://vidgen.x.ai/mock-video-12345.mp4",
    "duration": 8,
    "respect_moderation": true
  },
  "progress": 100,
  "usage": {
    "cost_in_usd_ticks": 400000000
  }
}

Dev frontend สามารถสร้าง UI player, ทดสอบ loading/success/fail ได้โดยไม่เปลืองเครดิต

กรณี 2: Test Scenario สำหรับ polling loop

Step 1: สร้าง POST /v1/videos/generations ดึง request_id ด้วย JSONPath $.request_id เก็บในตัวแปร
Step 2: สร้าง GET /v1/videos/{{videoRequestId}} ห่อด้วย for loop (หยุดเมื่อ status=="done") ใส่ wait 5 วินาที
Step 3: Assertion $.video.url ต้องไม่ว่าง

รันใน CI เพื่อจับ bug polling logic ได้อัตโนมัติ

Text-to-video vs image-to-video: เลือกใช้อย่างไร

text-to-video: สร้างฉากใหม่จาก prompt เหมาะกับเนื้อหาต้นฉบับ/ไม่มีรูปภาพ
image-to-video: เคลื่อนไหวรูปภาพที่มี เหมาะกับ assets, แบรนด์ หรือภาพวาด

ดู คู่มือ Grok image-to-video API สำหรับรายละเอียด

ตรวจจับ input: ถ้ามีภาพ ส่ง image-to-video, ถ้าไม่มี ส่ง text-to-video

ข้อผิดพลาดที่พบบ่อยและวิธีแก้ไข

401 Unauthorized: ตรวจสอบ API Key, header, คีย์หมดอายุหรือไม่
429 Too Many Requests: เกิน rate limit (60/min, 1/sec) เพิ่มดีเลย์ตรวจสอบสถานะอย่างน้อย 5s
status: "failed": Prompt โดน content moderation, ปรับแก้ prompt ใหม่
URL วิดีโอ 404: URL หมดอายุ ดาวน์โหลดทันทีหลังได้ URL
วิดีโอว่าง/ค้าง: Prompt คลุมเครือหรือไม่มี motion, เพิ่มคำอธิบายการเคลื่อนไหว
รอตรวจสอบสถานะนาน: 720p/คลิปยาวใช้เวลาสร้างนาน ใช้ 480p + สั้นๆ สำหรับ prototype

บทสรุป

Grok text-to-video API ใช้งานตรงไปตรงมา: ส่ง prompt, ได้ request_id, poll จน "done", โหลด MP4

เน้นเข้าใจ async flow (polling) ก่อน ส่วนพารามิเตอร์อื่นๆ เช่น ระยะเวลา, ความละเอียด, อัตราส่วน, รูปภาพอ้างอิง สามารถปรับแต่งได้ง่าย

ติดตามค่าใช้จ่ายด้วย cost_in_usd_ticks
จำลอง endpoint ทั้งสองใน Apidog เพื่อให้ dev frontend ทำงานได้เร็ว
ใช้ Test Scenarios ตรวจสอบ polling logic ได้อัตโนมัติ

ดาวน์โหลด Apidog ฟรีเพื่อตั้งค่า mock server และ test scenarios สำหรับ Grok video API ของคุณ

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

Q: ใช้ชื่อโมเดลอะไรสร้างวิดีโอจากข้อความ?

A: ใช้ "grok-imagine-video" ใส่ในฟิลด์ model ขณะ POST /v1/videos/generations

Q: สร้างวิดีโอนานแค่ไหน?

A: แล้วแต่ duration/resolution 480p สั้นๆ ประมาณ 30 วินาที, 720p ยาวๆ หลายนาที Poll ทุก 5-10 วินาที

Q: สร้างวิดีโอยาวเกิน 15 วินาทีได้ไหม?

A: ไม่ได้ในการเรียกเดียว (duration สูงสุด 15s) ใช้ POST /v1/videos/extensions ต่อฟุตเทจ

Q: ดาวน์โหลดวิดีโอที่สร้างได้อย่างไร?

A: ใช้ URL จาก result.video.url ใน polling ที่ status = done โหลดทันที URL จะหมดอายุ

Q: ถ้า prompt โดน moderation?

A: status จะเป็น "failed" ฟิลด์ respect_moderation = true ให้แก้ prompt แล้วลองใหม่

Q: มีบริการฟรีสำหรับ video API ไหม?

A: ไม่มีฟรี xAI คิดค่าบริการตามวินาที ดูข้อเสนอเครดิตใน console.x.ai

Q: reference_images ต่างจาก image-to-video ยังไง?

A: reference_images ช่วยชี้นำสไตล์เท่านั้น ไม่กลายเป็นตัวแบบ ส่วน image-to-video รูปภาพต้นฉบับคือเฟรมแรกจริง

Q: ทดสอบ polling loop โดยไม่เสียเครดิตยังไง?

A: ใช้ Smart Mock ของ Apidog จำลองทั้ง generation/poll endpoint ได้ครบทุกสถานะ

วิธีใช้ Grok Image to Video API แบบละเอียด (พร้อมคู่มือทีละขั้นตอน)

Thanawat Wongchai — Fri, 03 Apr 2026 08:45:52 +0000

สรุปสาระสำคัญ

Grok image-to-video API ใช้โมเดล grok-imagine-video เพื่อเปลี่ยนภาพนิ่งให้เป็นคลิปวิดีโอที่มีการเคลื่อนไหว คุณส่ง URL รูปภาพ พรอมต์ และการตั้งค่าเพิ่มเติมไปยัง https://api.x.ai/v1/videos/generations ด้วยเมธอด POST API จะส่ง request_id กลับมาทันที จากนั้นคุณจะทำการเรียก GET /v1/videos/{request_id} ซ้ำๆ จนกว่า status จะเป็น "done" ความยาวของวิดีโออยู่ระหว่าง 1 ถึง 15 วินาที ราคาเริ่มต้นที่ $0.05 ต่อวินาทีสำหรับวิดีโอความละเอียด 480p

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

บทนำ

เมื่อวันที่ 28 มกราคม 2026 xAI ได้เปิดตัวโมเดล grok-imagine-video ให้เข้าถึงผ่าน API สาธารณะ ภายในเดือนแรก โมเดลนี้สร้างวิดีโอได้ถึง 1.2 พันล้านรายการ และติดอันดับหนึ่งบนกระดานผู้นำ text-to-video ของ Artificial Analysis Image-to-video เป็นหนึ่งในคุณสมบัติเด่น: คุณส่งรูปถ่ายและพรอมต์บรรยายไปยัง API แล้ว API จะเปลี่ยนรูปถ่ายนั้นให้กลายเป็นคลิปวิดีโอสั้นๆ พร้อมให้ดาวน์โหลดในรูปแบบ MP4

กระบวนการแบบอะซิงโครนัสนี้ ที่คุณส่งงานแล้วรอผลลัพธ์ ทำให้เกิดความท้าทายในการทดสอบที่นักพัฒนาหลายคนมองข้ามไป การรวมระบบของคุณยังไม่เสร็จสิ้นเมื่อ POST แรกส่งคืนค่า 200 แต่จะเสร็จสิ้นเมื่อคุณยืนยันว่าการวนลูปเพื่อตรวจสอบสถานะสามารถจัดการสถานะ "processing", "done", และ "failed" ได้อย่างถูกต้องภายใต้สภาพเครือข่ายจริง

Test Scenarios ของ Apidog แก้ปัญหานี้ได้โดยตรง คุณสามารถสร้างลำดับการทำงานแบบต่อเนื่องได้: ส่งคำขอ POST ไปยัง /v1/videos/generations, ดึงค่า request_id ออกมา, วนลูปเพื่อตรวจสอบสถานะจนกว่า status == "done", จากนั้นยืนยันว่ามี URL ของวิดีโออยู่ ดาวน์โหลด Apidog ฟรี เพื่อทำตามขั้นตอนการทดสอบในส่วนถัดไปของคู่มือนี้

Grok image to video API คืออะไร?

Grok image-to-video API เป็นส่วนหนึ่งของผลิตภัณฑ์สร้างวิดีโอของ xAI API นี้ทำงานภายใต้โมเดล grok-imagine-video และรับรูปภาพเป็นเฟรมเริ่มต้นของวิดีโอที่สร้างขึ้น โมเดลจะวิเคราะห์เนื้อหาของรูปภาพและพรอมต์ข้อความ จากนั้นสร้างการเคลื่อนไหวที่เป็นธรรมชาติเพื่อทำให้ฉากนั้นมีชีวิตชีวา

API endpoint คือ:

POST https://api.x.ai/v1/videos/generations

การยืนยันตัวตนใช้ Bearer token มาตรฐาน:

Authorization: Bearer YOUR_XAI_API_KEY

คุณสามารถรับคีย์ได้จาก xAI console API เดียวกันนี้ยังรองรับ text-to-video (โดยละเว้นพารามิเตอร์ image), การต่อเติมวิดีโอ, และการแก้ไขวิดีโออีกด้วย

กระบวนการทำงานของ image-to-video

พารามิเตอร์ image ใน request body กำหนด เฟรมแรก ของวิดีโอที่สร้างขึ้น โมเดลไม่ได้แทนที่รูปภาพ แต่เริ่มต้นจากรูปภาพนั้น ทุกพิกเซลในเฟรมแรกมาจากรูปภาพต้นฉบับของคุณ จากนั้นโมเดลจะทำนายว่าฉากนั้นจะเคลื่อนไหวไปข้างหน้าตามเวลาอย่างไร โดยอ้างอิงจากพรอมต์ของคุณ

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

ซึ่งแตกต่างจาก text-to-video ที่โมเดลจะสร้างเฟรมแรกขึ้นมาเองทั้งหมด Image-to-video ช่วยให้คุณควบคุมฉากเริ่มต้นได้อย่างแม่นยำ

เมื่อไรควรเลือก image-to-video:

มีรูปภาพผลิตภัณฑ์ ทิวทัศน์ หรือภาพบุคคลอยู่แล้วที่ต้องการทำให้เคลื่อนไหว
สินทรัพย์ของแบรนด์คุณต้องการอัตลักษณ์ทางภาพที่สอดคล้องกันในเฟรมแรก
ต้องการให้การเคลื่อนไหวรู้สึกเหมือนมาจากฉากจริงหรือฉากที่เฉพาะเจาะจง

ควรเลือก text-to-video เมื่อ:

กำลังสำรวจแนวคิดภาพโดยไม่มีภาพอ้างอิง
ต้องการให้โมเดลเป็นผู้กำหนดองค์ประกอบของฉากทั้งหมด
ความเร็วในการทำซ้ำมีความสำคัญมากกว่าความแม่นยำของเฟรมแรก

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

ก่อนเรียก API ครั้งแรก เตรียมสิ่งต่อไปนี้:

บัญชี xAI ที่ console.x.ai
API key จาก xAI console. แนะนำให้เก็บไว้ในตัวแปรสภาพแวดล้อม
Python 3.8+ หรือ Node.js 18+ (ตัวอย่างนี้มีทั้งสองภาษา)
URL ของรูปภาพที่เข้าถึงได้จากสาธารณะ หรือรูปภาพที่เข้ารหัส base64 เป็น data URI

ตั้งค่าคีย์ของคุณเป็น environment variable:

export XAI_API_KEY="your_key_here"

ติดตั้ง xAI Python SDK (หากต้องการใช้งานไคลเอนต์ระดับสูง):

pip install xai-sdk

สำหรับ HTTP request ตรง ใช้แค่ requests (Python) หรือ fetch (Node.js)

การสร้างคำขอ image-to-video ครั้งแรก

การใช้งาน curl

curl -X POST https://api.x.ai/v1/videos/generations \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "prompt": "Gentle waves move across the surface, morning mist rises slowly",
    "image": {
      "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/1/1a/24701-nature-natural-beauty.jpg/1280px-24701-nature-natural-beauty.jpg"
    },
    "duration": 6,
    "resolution": "720p",
    "aspect_ratio": "16:9"
  }'

การตอบกลับจะมาทันทีพร้อมกับ request_id:

{
  "request_id": "d97415a1-5796-b7ec-379f-4e6819e08fdf"
}

วิดีโอจะยังไม่พร้อมใช้งาน ต้องตรวจสอบสถานะด้วย Polling

การใช้งาน Python (request ตรง)

import os
import requests

api_key = os.environ["XAI_API_KEY"]

payload = {
    "model": "grok-imagine-video",
    "prompt": "Gentle waves move across the surface, morning mist rises slowly",
    "image": {
        "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/1/1a/24701-nature-natural-beauty.jpg/1280px-24701-nature-natural-beauty.jpg"
    },
    "duration": 6,
    "resolution": "720p",
    "aspect_ratio": "16:9"
}

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json"
}

response = requests.post(
    "https://api.x.ai/v1/videos/generations",
    json=payload,
    headers=headers
)

data = response.json()
request_id = data["request_id"]
print(f"Job started: {request_id}")

การใช้งานรูปภาพ Base64

หากใช้ไฟล์ local หรือไม่เผยแพร่ URL:

import base64

with open("my_image.jpg", "rb") as f:
    encoded = base64.b64encode(f.read()).decode("utf-8")

payload["image"] = {
    "url": f"data:image/jpeg;base64,{encoded}"
}

การตรวจสอบผลลัพธ์ (Polling)

API จะส่ง request_id กลับมา ให้คุณตรวจสอบสถานะที่ endpoint นี้:

GET https://api.x.ai/v1/videos/{request_id}

สถานะหลักที่ต้องสนใจ:

สถานะ	ความหมาย
`"processing"`	วิดีโอกำลังถูกเรนเดอร์
`"done"`	วิดีโอพร้อมใช้งานแล้ว URL อยู่ในการตอบกลับ
`"failed"`	เกิดข้อผิดพลาด

ตัวอย่างการตอบกลับ:

{
  "status": "done",
  "video": {
    "url": "https://vidgen.x.ai/....mp4",
    "duration": 6
  },
  "progress": 100
}

ตัวอย่างวนลูป Polling ด้วย Python

import time

def poll_video(request_id: str, api_key: str, interval: int = 5) -> dict:
    url = f"https://api.x.ai/v1/videos/{request_id}"
    headers = {"Authorization": f"Bearer {api_key}"}

    while True:
        response = requests.get(url, headers=headers)
        data = response.json()
        status = data.get("status")

        print(f"Status: {status} | Progress: {data.get('progress', 0)}%")

        if status == "done":
            return data["video"]
        elif status == "failed":
            raise RuntimeError(f"Video generation failed for {request_id}")

        time.sleep(interval)

# Usage
video = poll_video(request_id, api_key)
print(f"Video URL: {video['url']}")
print(f"Duration: {video['duration']}s")

แนะนำ: กำหนด interval อย่างน้อย 5 วินาที เพื่อลดโอกาสโดน rate limit (60 requests ต่อนาที)

การใช้งาน xAI Python SDK

xai-sdk จะ handle async loop ให้โดยอัตโนมัติ:

from xai_sdk import Client
import os

client = Client(api_key=os.environ["XAI_API_KEY"])

video = client.video.generate(
    model="grok-imagine-video",
    prompt="Gentle waves move across the surface, morning mist rises slowly",
    image={"url": "https://example.com/landscape.jpg"},
    duration=6,
    resolution="720p",
    aspect_ratio="16:9"
)

print(f"Video URL: {video.url}")
print(f"Duration: {video.duration}s")

ถ้าอยากควบคุม polling interval/retry/log เอง แนะนำใช้ request ตรง

การควบคุมความละเอียด, ระยะเวลา และอัตราส่วนภาพ

ระยะเวลา (Duration)

duration รับค่าระหว่าง 1–15 วินาที (ค่า default = 6):

"duration": 10

ความละเอียด (Resolution)

ค่า	คำอธิบาย
`"480p"`	ค่าเริ่มต้น. ราคาต่ำ, เร็ว
`"720p"`	คุณภาพสูงกว่า. $0.07/วินาที

"resolution": "720p"

อัตราส่วนภาพ (Aspect ratio)

ค่า	กรณีใช้งาน
`"16:9"`	ค่าเริ่มต้น. จอกว้าง
`"9:16"`	แนวตั้งสำหรับมือถือ/สตอรี่
`"1:1"`	สี่เหลี่ยมสำหรับโซเชียล
`"4:3"`	ภาพถ่ายคลาสสิก
`"3:4"`	บุคคลแนวตั้ง
`"3:2"`	มาตรฐานการคร็อป
`"2:3"`	บุคคลแนวตั้งสูง

หากระบุ image ค่า default aspect ratio จะเท่ากับรูปต้นฉบับ หากต้องการเปลี่ยน ให้กำหนดเอง

การใช้รูปภาพอ้างอิงเพื่อเป็นแนวทางสไตล์

image: รูปต้นฉบับที่เป็นเฟรมแรก
reference_images: อาร์เรย์ (สูงสุด 7 รูป) เป็นแนวทางสไตล์/เนื้อหา ไม่ใช่เฟรม

{
  "model": "grok-imagine-video",
  "prompt": "A product rotating slowly on a clean white surface",
  "image": {
    "url": "https://example.com/product-shot.jpg"
  },
  "reference_images": [
    {"url": "https://example.com/brand-style-reference-1.jpg"},
    {"url": "https://example.com/lighting-reference.jpg"}
  ],
  "duration": 6,
  "resolution": "720p"
}

reference_images สามารถใช้เดี่ยวๆ (text-to-video) หรือร่วมกับ image ก็ได้

การต่อเติมและแก้ไขวิดีโอ

การต่อเติมวิดีโอ

POST /v1/videos/extensions สร้างคลิปต่อจากวิดีโอเดิม (สูงสุด 15 วินาทีต่อรอบ):

curl -X POST https://api.x.ai/v1/videos/extensions \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "video_id": "your_original_request_id",
    "prompt": "The mist continues to lift as sunlight breaks through",
    "duration": 5
  }'

Polling status เหมือนเดิมที่ GET /v1/videos/{request_id}

การแก้ไขวิดีโอ

POST /v1/videos/edits แก้ไขวิดีโอเดิมด้วยพรอมต์ใหม่:

curl -X POST https://api.x.ai/v1/videos/edits \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "video_id": "your_original_request_id",
    "prompt": "Change the sky to a dramatic sunset with deep orange tones"
  }'

ทั้งสองแบบ polling รูปแบบเดียวกัน

รายละเอียดราคา: วิดีโอ 10 วินาทีมีค่าใช้จ่ายเท่าไร

ส่วนประกอบ	ค่าใช้จ่าย
รูปภาพอินพุต	$0.002 ต่อรูป
วิดีโอ 480p	$0.05 ต่อวินาที
วิดีโอ 720p	$0.07 ต่อวินาที

ตัวอย่าง 1: วิดีโอ 10 วินาที 720p

รูปภาพอินพุต: $0.002
วิดีโอ: 10 × $0.07 = $0.70
รวม: $0.702

ตัวอย่าง 2: วิดีโอ 6 วินาที 480p

รูปภาพอินพุต: $0.002
วิดีโอ: 6 × $0.05 = $0.30
รวม: $0.302

หมายเหตุ: Text-to-video (ไม่มี image) จะไม่มีค่าอินพุต $0.002

วิธีทดสอบการเชื่อมต่อ Grok video API ของคุณด้วย Apidog

API แบบ async ต้องทดสอบแบบลำดับหลายขั้นตอน (ไม่ใช่แค่ request ครั้งเดียว):

POST สร้างวิดีโอ รับ request_id
GET ตรวจสอบสถานะ ต้อง handle "processing" ระหว่างรอ
GET จน status == "done" และมี URL จริง

ขั้นตอนการสร้าง Test Scenario ใน Apidog

1. สร้าง Test Scenario ใหม่

ใน Apidog ไปที่โมดูล Tests > กด + สร้าง scenario ใหม่ ตั้งชื่อ “Grok image-to-video async flow”

2. เพิ่มคำขอ POST สร้างวิดีโอ

URL: https://api.x.ai/v1/videos/generations
Method: POST
Header: Authorization: Bearer {{xai_api_key}}
Body:

{
  "model": "grok-imagine-video",
  "prompt": "Gentle mist rises from the water as light filters through the trees",
  "image": {
    "url": "https://example.com/your-test-image.jpg"
  },
  "duration": 6,
  "resolution": "480p"
}

3. ดึงค่า request_id

หลัง POST เพิ่ม processor Extract Variable

Variable name: video_request_id
Source: Response content
JSONPath: $.request_id

Apidog จะเก็บไว้ใน {{video_request_id}}

4. สร้าง Polling Loop

ใช้ processor For loop

ในลูปเพิ่ม GET ตรวจสอบสถานะ:

URL: https://api.x.ai/v1/videos/{{video_request_id}}
Method: GET
Header: Authorization: Bearer {{xai_api_key}}

ดึงสถานะ:

Extract Variable: video_status
JSONPath: $.status

เพิ่ม processor Wait (5000ms) ในลูป

ตั้ง Break If: {{video_status}} == "done"

5. ยืนยัน URL ของวิดีโอ

หลังจบลูป เพิ่ม GET สุดท้าย แล้วใช้ processor Assertion

Field: $.video.url
Condition: not empty

6. รัน Scenario

คลิก Run ที่หน้า Test scenario

Apidog จะ POST, ดึง request_id, Poll ซ้ำ, ตรวจสอบสถานะ, และ Assert URL รายงานแสดง status/ระยะเวลาทุกขั้น

เชื่อมต่อ scenario นี้กับ CI/CD pipeline ได้ด้วย:

apidog run --scenario grok-video-async-flow --env production

ข้อผิดพลาดที่พบบ่อยและการแก้ไข

401 Unauthorized: ตรวจสอบ API key และรูปแบบ Authorization header
422 Unprocessable Entity: Body ผิด ฟิลด์ขาด/พรอมต์ว่าง/URL รูปภาพเข้าไม่ได้
URL รูปภาพเข้าไม่ได้: xAI ต้องเข้าถึงได้ ใช้ public CDN หรือ base64 data URI
สถานะค้างที่ "processing": อาจใช้เวลาหลายนาที ถ้าเกิน 10 นาทีให้ส่ง request ใหม่
Rate limit error (429): จำกัด 60 requests/นาที, 1 request/วินาที เพิ่ม delay ใน polling
Base64 ถูกปฏิเสธ: ตรวจ prefix data URI, ใช้ data:image/jpeg;base64,
อัตราส่วนภาพไม่ตรง: หาก aspect ratio แตกต่างมาก อาจโดนคร็อป หรือเกิด letterbox

สรุป

Grok image-to-video API ให้คุณแปลงภาพนิ่งเป็นวิดีโอแอนิเมชันด้วยโมเดล grok-imagine-video เพียง POST รูปภาพและพรอมต์ รับ request_id ตรวจสอบสถานะ และดาวน์โหลดไฟล์ MP4 ได้โดยตรง รูปแบบ polling แบบ async คือจุดที่ integration มักเกิดปัญหา การทดสอบด้วย Apidog Test Scenario ครอบคลุมการ Extract Variable, วนลูป polling พร้อมเงื่อนไขหยุด และยืนยันผลลัพธ์ ลดข้อผิดพลาดก่อน production

เริ่มต้นสร้างการเชื่อมต่อของคุณด้วย Apidog ฟรี ไม่ต้องใช้บัตรเครดิต

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

Q: ฉันควรใช้ชื่อโมเดลใดสำหรับ Grok image-to-video API?

A: grok-imagine-video ใส่ในฟิลด์ model ของ request body

Q: พารามิเตอร์ image กับ reference_images ต่างกันอย่างไร?

A: image กำหนดเฟรมแรก, reference_images ให้แนวทางสไตล์/เนื้อหาโดยไม่ใช่เฟรม

Q: การสร้างวิดีโอใช้เวลานานเท่าไร?

A: ขึ้นอยู่กับความละเอียดและระยะเวลา โดยเฉลี่ย 1–3 นาที (6 วินาที 480p), 4–8 นาที (15 วินาที 720p)

Q: ส่งไฟล์ local เป็นภาพต้นฉบับได้ไหม?

A: ได้ ให้ encode เป็น base64 data URI แล้วส่งใน image.url

Q: ถ้าไม่ตั้ง aspect_ratio จะเป็นอย่างไร?

A: ถ้ามี image ค่า default จะเท่ากับสัดส่วนของรูป, ถ้าไม่มี (text-to-video) จะเป็น 16:9

Q: วิดีโอ 10 วินาที 720p ราคาเท่าไร?

A: รูปภาพอินพุต $0.002 + วิดีโอ $0.70 รวม $0.702

Q: API rate limit เท่าไร?

A: 60 requests/นาที และ 1 request/วินาที (รวม POST + GET)

Q: ต่อเติมวิดีโอให้ยาวเกิน 15 วินาทีได้ไหม?

A: ได้ ใช้ endpoint /v1/videos/extensions ต่อเติมทีละ 15 วินาที Polling แบบเดิม

ราคา Bird SMS API ปี 2026 เท่าไหร่

Thanawat Wongchai — Fri, 03 Apr 2026 07:13:50 +0000

สรุปสั้นๆ

API SMS ของ Bird เริ่มต้นที่ $0.00331 ต่อข้อความที่ส่งออกจากสหรัฐอเมริกา และ $0.003 ต่อข้อความที่ส่งเข้าสหรัฐอเมริกา ถือเป็นหนึ่งในราคาเริ่มต้นที่ถูกที่สุดในกลุ่มผู้ให้บริการ SMS API รายใหญ่ คุณยังสามารถใช้แพลนฟรี ส่ง SMS ได้ 5 ข้อความต่อวันเพื่อทดลองก่อนตัดสินใจ ส่วนแพลน Pro $49/เดือน ครอบคลุม SMS 1,000 ข้อความ

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

บทนำ

MessageBird ได้รีแบรนด์เป็น Bird ในปี 2023 โดยเน้น Omnichannel ที่ขับเคลื่อนด้วย AI: SMS, WhatsApp, อีเมล และเสียง อยู่ในแพลตฟอร์มเดียวกัน โครงสร้างราคาถูกเปลี่ยนเป็นแบบจ่ายตามการใช้งานที่โปร่งใส ทำให้ต้นทุน SMS ของ Bird ต่ำกว่า Twilio, Vonage และผู้ให้บริการรายใหญ่อื่นๆ ส่วนใหญ่

💡

หากคุณกำลังสร้าง integration กับ SMS คุณต้องการข้อมูลราคาที่แม่นยำและวิธีทดสอบ API อย่างรวดเร็ว Apidog ให้คุณออกแบบ request, รัน test case และตรวจสอบ response ของ Bird SMS API ได้ทันทีโดยไม่ต้องเขียนโค้ด ลองใช้ Apidog ฟรีที่ apidog.com และทดสอบ integration Bird SMS ของคุณภายในไม่กี่นาที

บทความนี้จะลงลึกเรื่องค่าใช้จ่ายของ Bird SMS ปี 2025–2026, ปัจจัยที่อาจทำให้ต้นทุนเพิ่มขึ้น และเปรียบเทียบ Bird กับทางเลือกอื่น

ภาพรวมราคา SMS ของ Bird

Bird ใช้โครงสร้างราคาแบบสองส่วนสำหรับ SMS:

ค่าธรรมเนียมแพลตฟอร์ม (รายเดือน)
ค่าธรรมเนียมต่อข้อความ (จ่ายตามการใช้งานเกินแพลน)

แพลน	ค่าใช้จ่ายรายเดือน	SMS ที่รวมในแพลน
ฟรี	$0	5 SMS/วัน
Pro	$49	1,000 SMS/เดือน
Enterprise	กำหนดเอง	ปริมาณกำหนดเอง

เมื่อส่ง SMS เกินจากแพลน จะคิดค่าบริการดังนี้ (สำหรับหมายเลขในสหรัฐอเมริกา):

SMS ขาออก: $0.00331 ต่อข้อความ
SMS ขาเข้า: $0.003 ต่อข้อความ

ราคาสำหรับ CRM/Marketing Automation แสดงเป็น EUR ในหน้าราคาของ Bird ตัวเลข USD ในที่นี้สำหรับ API/นักพัฒนา ตรวจสอบตารางราคาปัจจุบันที่ bird.com/en/pricing/sms เสมอ

รายละเอียดราคา: SMS, MMS, WhatsApp และอีเมล

SMS

อัตราขาออกจากสหรัฐอเมริกา: $0.00331 ต่อข้อความ Bird เชื่อมต่อกับผู้ให้บริการในกว่า 150 ประเทศ ราคาต่อประเทศแตกต่างกัน เช่น:

ประเทศ	อัตราขาออก (โดยประมาณ)
สหรัฐอเมริกา	~$0.00331
สหราชอาณาจักร	~€0.036
ออสเตรเลีย	~€0.009
เยอรมนี	~€0.056
อินเดีย	แตกต่างกันไปตามเส้นทาง
บราซิล	~€0.047

หมายเหตุ: ข้อความในสหรัฐอเมริกา/แคนาดามีค่าธรรมเนียมผู้ให้บริการ (10DLC, Toll-Free) เพิ่มเติมจากอัตราพื้นฐาน

MMS

MMS (ข้อความรูปภาพ) มีค่าใช้จ่ายสูงกว่า SMS รองรับเฉพาะสหรัฐและแคนาดา อัตราประมาณ 3–5 เท่าของ SMS ขึ้นอยู่กับแพลน ตรวจสอบ bird.com/en/pricing/sms สำหรับอัตรา MMS ล่าสุด

Bird คิดค่าบริการสองส่วน:

ค่าธรรมเนียมประมวลผล Bird (ต่อ 1,000 ข้อความ):

ปริมาณ	ค่าธรรมเนียมต่อ 1,000 ข้อความ
1 – 1,000	$0.001
1,001 – 100,000	$0.005
100,001 – 500,000	$0.0045
500,001+	$0.004

ค่าธรรมเนียม Meta passthrough (คิดตามการสนทนา แตกต่างตามประเทศ/ประเภท)
- สหรัฐอเมริกา:
  - การตลาด: $0.0250
  - สาธารณูปโภค/ยืนยันตัวตน: $0.0034

Bird ส่งผ่านค่าธรรมเนียม Meta ตามราคาต้นทุน

อีเมล

API อีเมล เริ่มที่ $0.001 ต่อฉบับ ปริมาณมากราคาลดลง แพลน Pro รวม 10,000 อีเมล/เดือน

เสียง

API เสียง คิดตามการใช้งาน โทรออกในสหรัฐฯ ~$0.013–$0.015 ต่อนาที โทรเข้าถูกกว่า ติดต่อ Bird หากส่งปริมาณมาก

ปัจจัยที่ส่งผลต่อค่าใช้จ่าย Bird ของคุณ

1. กำหนดเส้นทางตามประเทศและผู้ให้บริการ

SMS สหรัฐฯ ราคา $0.00331 แต่ประเทศอื่นอาจสูงกว่า 10–80 เท่า (เช่น เยอรมนี ~€0.056) ตรวจสอบ Bird rate table ก่อนประมาณค่าใช้จ่ายระหว่างประเทศ

2. ประเภทหมายเลข

Long codes (10DLC): ต้องลงทะเบียนแบรนด์/แคมเปญ (TCR)
Short codes: 5–6 หลัก, ปริมาณสูง, ค่าเช่ารายเดือนสูง ($500–$1,000)
Toll-free numbers: ค่าเช่ารายเดือนต่ำกว่า, ปริมาณปานกลาง

ค่าเช่าหมายเลขรายเดือนคิดแยกจากค่าบริการต่อข้อความ

3. ความยาวข้อความและการเข้ารหัส

SMS มาตรฐาน: 160 ตัวอักษร (GSM-7)
เกิน 160 ตัวอักษร = โดนหั่นเป็นหลายส่วน คิดเงินแยกแต่ละส่วน
Unicode (เช่น emoji, ตัวอักษรพิเศษ): จำกัด 70 ตัวอักษร/ส่วน

4. การผสมผสานช่องทาง

ถ้า workflow ส่งข้อความ fallback ไป WhatsApp เมื่อ SMS ล้มเหลว จะมีค่าใช้จ่าย WhatsApp เพิ่ม ตรวจสอบ workflow ใน Flow Builder ก่อนใช้งานจริง

5. ปริมาณ

Bird ไม่มี volume discount แบบเปิดเผย ผู้ส่งปริมาณมาก (ล้านข้อความ/เดือน) สามารถดีลอัตรา custom กับ Bird (Enterprise Plan)

ค่าใช้จ่ายและค่าธรรมเนียมแอบแฝง

ค่าธรรมเนียมผู้ให้บริการในสหรัฐอเมริกา (10DLC)

ลงทะเบียนแบรนด์: ครั้งเดียว ($4–$44)
ลงทะเบียนแคมเปญ: รายเดือน (~$10/เดือน)
ค่าบริการต่อข้อความ: เพิ่มอีกเล็กน้อย/ข้อความ

ค่าธรรมเนียมนี้ถูกกำหนดโดยผู้ให้บริการ (AT&T, T-Mobile, Verizon) Bird ส่งผ่านโดยไม่บวกกำไร

ค่าเช่าหมายเลขโทรศัพท์

Long code US: $1–$2/เดือน
Toll-free: $2–$3/เดือน
Short code: $500–$1,000/เดือน

Webhooks และการประมวลผลขาเข้า

รับ SMS ขาเข้า คิดอัตราขาเข้า ($0.003/ข้อความ) ใช้งานเช่น reply opt-out หรือ คำหลักช่วยเหลือ จะคิดเงินตามนี้

ค่าสมัครสมาชิกแพลตฟอร์ม

Pro $49/เดือน คือค่าใช้จ่ายคงที่ SMS 1,000 ข้อความ/เดือน เกินนี้คิดค่าบริการตามอัตรา

Bird เปรียบเทียบกับทางเลือกอื่นอย่างไร

ผู้ให้บริการ	SMS ขาออก (US)	SMS ขาเข้า (US)	หมายเหตุ
Bird	$0.00331	$0.003	อัตราพื้นฐานต่ำสุด; Omnichannel platform
Twilio	$0.0079	$0.0079	อัตราสูงกว่า; ระบบนิเวศขนาดใหญ่
Telnyx	~$0.004	~$0.001	แข่งขันได้; เชื่อมต่อผู้ให้บริการโดยตรง
Plivo	$0.0055	$0.0005	ขาเข้าถูกกว่า; แพลตฟอร์มเรียบง่าย

Bird ถูกกว่า Twilio มากในอัตราเริ่มต้น Telnyx และ Plivo ก็แข่งขันได้ ถ้าต้องการ SMS + WhatsApp + Email + Automation ในแพลตฟอร์มเดียว Bird คุ้มราคา ถ้าเน้นเฉพาะ SMS API พื้นฐาน Telnyx/Plivo อาจเหมาะกว่า

วิธีการเริ่มต้นใช้งาน Bird

สร้างบัญชีฟรี ที่ bird.com แพลนฟรีส่ง SMS ได้ 5 ข้อความ/วัน โดยไม่ต้องใช้บัตรเครดิต
ลงทะเบียนแบรนด์และแคมเปญ ผ่านแดชบอร์ด Bird เพื่อให้สอดคล้องกับข้อกำหนด 10DLC (US) ใช้เวลา 1–3 วันทำการ
รับหมายเลขโทรศัพท์ จัดเตรียมหมายเลข long code ได้ผ่าน Numbers API หรือแดชบอร์ด
ทดสอบ API เบื้องต้น Bird ใช้ REST API (JSON) ตัวอย่างการส่ง SMS:

   curl -X POST 'https://api.bird.com/messages' \
     -H 'Authorization: AccessKey YOUR_API_KEY' \
     -H 'Content-Type: application/json' \
     -d '{
       "originator": "+1234567890",
       "recipients": ["+1987654321"],
       "body": "ข้อความทดสอบจาก Bird API"
   }'

ดูคู่มือเต็มได้ที่ docs.bird.com (รองรับ SDK: Node.js, Python, PHP, Go, Java, Ruby) และตั้งค่า webhook ได้ทันที

บทสรุป

Bird SMS API เสนออัตราเริ่มต้นต่ำสุดในตลาด ($0.00331/ข้อความขาออก US) แพลนฟรีช่วยให้ทดสอบ API ได้โดยไม่ต้องใช้บัตรเครดิต แพลน Pro เหมาะกับทีมที่เริ่มต้น ($49/เดือน 1,000 SMS)

ตรวจสอบต้นทุนแฝง: ค่าธรรมเนียม 10DLC, ค่าเช่าหมายเลข, อัตราต่างประเทศที่สูงกว่ามาก รวมสิ่งเหล่านี้ในการประเมินงบประมาณตั้งแต่ต้น

เคล็ดลับ: ใช้ Apidog ทดสอบ integration Bird SMS แบบ end-to-end ก่อน production ช่วยสร้าง request, กำหนด environment, เชื่อมโยง test case และ validate delivery ได้ในที่เดียว

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

ราคา API SMS ของ Bird ต่อข้อความในสหรัฐอเมริกาเท่าไหร่?

$0.00331 ต่อ SMS ขาออก, $0.003 ต่อ SMS ขาเข้า (US) อัตรานี้เป็นระดับ API นักพัฒนา มีค่าธรรมเนียม 10DLC เพิ่มเติม

Bird กับ MessageBird คือบริษัทเดียวกันหรือไม่?

ใช่ MessageBird เปลี่ยนชื่อเป็น Bird ในปี 2023 บริษัทก่อตั้งปี 2011 ลูกค้า Heineken, Booking.com, Uber, eBay จุดสิ้นสุด API เดิมบางส่วนยังใช้ชื่อ MessageBird

คิดค่าบริการ SMS ขาเข้าหรือไม่?

ใช่ Bird คิด $0.003 ต่อข้อความขาเข้าใน US ข้อความ opt-out/คำหลักช่วยเหลือ นับเป็นขาเข้า

แพลนฟรีของ Bird มีอะไรบ้าง?

5 SMS/วัน, 10 อีเมล/วัน, 15 ข้อความ AI/วัน เข้าถึง API สาธารณะโดยไม่ต้องใช้บัตรเครดิต เหมาะกับการทดสอบ API

SMS ของ Bird ถูกกว่า Twilio หรือไม่?

Bird ($0.00331) ถูกกว่า Twilio ($0.0079) มาก สำหรับ 100,000 ข้อความ/เดือน Bird ประมาณ $331, Twilio $790 (ยังไม่รวม discount ปริมาณของ Twilio)

ค่าธรรมเนียมแอบแฝง Bird SMS มีอะไรบ้าง?

มีค่าธรรมเนียม 10DLC (ลงทะเบียนแบรนด์, แคมเปญ, ต่อข้อความ), ค่าเช่าหมายเลข ($1–$2/เดือน long code), ข้อความต่างประเทศราคาสูงกว่าข้อความ US มาก

จะทดสอบ Bird SMS API โดยไม่ส่งข้อความจริงได้อย่างไร?

ใช้ Smart Mock ของ Apidog จำลอง response ของ Bird API ระหว่าง dev หรือส่งข้อความทดสอบไปยังเบอร์ยืนยันผ่าน sandbox ของ Bird Apidog ช่วยเชื่อมโยง request และ validate response โดยไม่ต้องแตะ production

หากต้องการเริ่มต้นทดสอบ Bird SMS API อย่างรวดเร็วและไม่ยุ่งยากกับ production แนะนำให้ทดลองใช้ Apidog วันนี้!

ราคา Twilio SMS API ปี 2026: เจาะลึกทุกรายละเอียด

Thanawat Wongchai — Fri, 03 Apr 2026 04:02:46 +0000

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

SMS long code ของสหรัฐฯ (ขาออกและขาเข้า): $0.0083 ต่อข้อความ
MMS ขาออก: $0.022 ต่อข้อความ; MMS ขาเข้า: $0.0165 ต่อข้อความ
SMS หมายเลขโทรฟรี: $0.0083 ต่อข้อความ บวกค่าธรรมเนียมผู้ให้บริการเครือข่าย
ค่าเช่า Short code: $1,000/เดือน สำหรับรหัสแบบสุ่ม; $1,500/เดือน สำหรับรหัสเฉพาะ (vanity code)
การลงทะเบียนแบรนด์ 10DLC: ค่าธรรมเนียมครั้งเดียว $4.50 (อัปเดตสิงหาคม 2025); แคมเปญตั้งแต่ $1.50 ถึง $10/เดือน
หมายเลขโทรศัพท์ (long code): $1.15/เดือน; หมายเลขโทรฟรี: $2.15/เดือน
ค่าธรรมเนียมผู้ให้บริการเครือข่ายจะถูกบวกเพิ่มจากราคาพื้นฐานทั้งหมด
ส่วนลดตามปริมาณจะเริ่มใช้โดยอัตโนมัติเมื่อส่งข้อความเกิน 150,000 ข้อความต่อเดือน
มีให้ทดลองใช้ฟรี; ไม่ต้องใช้บัตรเครดิตในการเริ่มต้น

บทนำ

Twilio เป็น SMS API มาตรฐานสำหรับทีมพัฒนาส่วนใหญ่ เอกสารประกอบละเอียดถี่ถ้วน เวลาทำงานเชื่อถือได้ และ REST API ออกแบบมาอย่างดี แต่เมื่อคุณย้ายจากโปรเจกต์ส่วนตัวไปสู่แอปพลิเคชันจริง ค่าใช้จ่ายจะเพิ่มขึ้นอย่างรวดเร็ว เพราะคุณต้องจ่ายทั้งอัตราพื้นฐาน ค่าธรรมเนียมเครือข่าย ค่าหมายเลขโทรศัพท์ และอาจรวมถึงค่าลงทะเบียน 10DLC

ทดลองใช้ Apidog ได้เลย

💡 ก่อนสร้างการเชื่อมต่อ SMS: ทดสอบอย่างเหมาะสมด้วย Apidog สร้างสถานการณ์ทดสอบอัตโนมัติ ตรวจสอบ webhook ของ Twilio เทียบกับ OpenAPI spec ของคุณ ยืนยันรหัสสถานะ, ตรวจสอบ schema การตอบกลับ, และรัน contract test ใน CI/CD ได้

ลองใช้ Apidog ฟรีเพื่อตรวจสอบเวิร์กโฟลว์ SMS ของคุณก่อนนำไปใช้งานจริง

บทความนี้แจกแจงรายละเอียดค่าใช้จ่ายทุกรายการของ Twilio ชี้ให้เห็นปัจจัยต้นทุน สิ่งที่มักถูกมองข้าม และเปรียบเทียบ Twilio กับตัวเลือกอื่น

ภาพรวมการกำหนดราคา Twilio SMS

Twilio ใช้การกำหนดราคาแบบจ่ายตามการใช้งานจริง (pay-as-you-go)

คุณจ่ายตามจำนวน message segment, หมายเลขโทรศัพท์, และฟีเจอร์เสริมหรือค่า registration ไม่มีสัญญาหรือขั้นต่ำ เว้นแต่ขอ volume discount กับ Twilio

SMS long code สหรัฐฯ: $0.0083 ต่อ segment (ขาเข้า/ขาออก)
อย่าลืม: ค่าธรรมเนียมเครือข่าย, ค่าเช่าหมายเลข, และ registration ถูกบวกเพิ่มอัตโนมัติ

ส่วนลดตามปริมาณ: อัตโนมัติ เมื่อส่งเกิน 150,000 ข้อความต่อเดือน (ต่อประเภทหมายเลข)

การแจกแจงราคา: SMS, MMS, หมายเลขโทรฟรี และ short codes

SMS long code (หมายเลข 10 หลัก)

Long code คือหมายเลขมาตรฐานสำหรับ A2P (application-to-person) ในสหรัฐฯ

ประเภทข้อความ	ราคาต่อส่วน
SMS ขาออก	$0.0083
SMS ขาเข้า	$0.0083
MMS ขาออก	$0.022
MMS ขาเข้า	$0.0165

ข้อควรทราบ: Twilio คิดค่าบริการเป็น message segment ไม่ใช่ต่อข้อความ

ข้อความ GSM-7: 160 ตัวอักษร/segment
Unicode (อีโมจิ ฯลฯ): 70 ตัวอักษร/segment
ตัวอย่าง: 200 ตัวอักษร = 2 segment

หมายเลขโทรฟรี

SMS พื้นฐาน: $0.0083 ต่อส่วน (ขาเข้า/ขาออก)
MMS ขาออก: $0.022; MMS ขาเข้า: $0.02
ไม่ต้องลงทะเบียน 10DLC ประหยัดค่า setup
แนะนำสำหรับการส่งทางเดียวปริมาณมาก

Short code (หมายเลข 5-6 หลัก)

Short code เหมาะสำหรับแคมเปญปริมาณสูง อัตรา SMS ต่อข้อความเท่ากันแต่ค่าเช่าแพงกว่า

ประเภท Short code	ค่าใช้จ่ายรายเดือน
Short code แบบสุ่ม	$1,000/เดือน (เก็บเงินรายไตรมาส)
Short code เฉพาะ (Vanity)	$1,500/เดือน (เก็บเงินรายไตรมาส)
Bring-your-own vanity	$500/เดือน (เก็บเงินรายไตรมาส)

เปิดใช้ MMS มีค่าธรรมเนียมครั้งเดียว $500

ส่วนลดตามปริมาณ

Twilio ลดราคาอัตโนมัติเป็นขั้นตามปริมาณ:

ข้อความต่อเดือน	ราคาต่อส่วน
1-150,000	$0.0083
150,001-300,000	$0.0081
300,001-500,000	$0.0079
500,001-750,000	$0.0077
750,001-1,000,000	$0.0075
1,000,001+	$0.0073

ปริมาณแยกตามประเภทหมายเลข (long code, โทรฟรี, short code)

ปัจจัยที่ส่งผลต่อบิล Twilio ของคุณ

ประเภทหมายเลขโทรศัพท์

หมายเลขที่ใช้ส่งกำหนดตารางอัตราและ threshold ส่วนลด

ส่วนของข้อความ

ข้อความยาว/มี Unicode ถูกคิดหลาย segment ทำให้ต้นทุนพุ่ง

ค่าธรรมเนียมผู้ให้บริการเครือข่าย

ค่าเครือข่ายถูกบวกเพิ่มจากอัตราพื้นฐาน ตัวอย่าง SMS ขาออก long code:

ผู้ให้บริการ	ค่าธรรมเนียมขาออก
AT&T	$0.0035
T-Mobile	$0.0045
Verizon	$0.004
US Cellular	$0.005
อื่นๆ	$0.004

MMS ค่าธรรมเนียมสูงขึ้น (AT&T: +$0.009, T-Mobile: +$0.01)
ตัวอย่าง: ส่ง SMS ไปยัง AT&T = $0.0083 + $0.0035 = $0.0118 ต่อส่วน

ประเทศปลายทาง

UK: $0.04 / อินเดีย: $0.0029 / บราซิล: $0.075
ดาวน์โหลด CSV ราคาเต็มได้จาก Twilio

การลงทะเบียน 10DLC

ธุรกิจที่ส่ง A2P SMS บน long code ต้องลงทะเบียนแบรนด์+แคมเปญ ไม่ลงทะเบียนจะถูกกรองโดยเครือข่าย

ค่าใช้จ่ายและค่าธรรมเนียมแอบแฝง

ค่าธรรมเนียมการลงทะเบียน 10DLC

แบรนด์ (Sole Proprietor/Low Volume): $4.50 (ครั้งเดียว)
แบรนด์ Standard: $46 (ครั้งเดียว)
แคมเปญ: $15/ครั้ง (ตรวจสอบ), $1.50-$10/เดือน ขึ้นกับประเภท

ประเภทแคมเปญ	ค่าธรรมเนียมรายเดือน
Sole Proprietor	$2/เดือน
Low-volume mixed	$1.50/เดือน
Standard	$10/เดือน
การกุศล/501(c)(3)	$3/เดือน
บริการฉุกเฉิน	$5/เดือน

ตรวจสอบมาตรฐาน: $41.50
อุทธรณ์: $11
Retry Authentication Plus: $12.50

ค่าธรรมเนียมหมายเลขโทรศัพท์

Long code: $1.15/เดือน
โทรฟรี: $2.15/เดือน

ค่าธรรมเนียมข้อความล้มเหลว

$0.001 ต่อข้อความที่ status "ล้มเหลว"

ส่วนเสริมคุณสมบัติเสริม

Engagement Suite: $0.015 ต่อข้อความขาออก (1,000 ข้อความแรก/เดือนฟรี)
Compliance Toolkit: $0.015 ต่อข้อความขาออก

แผนการสนับสนุน

Developer plan: $250/เดือน
Enterprise support สูงกว่า

Twilio เปรียบเทียบกับทางเลือกอื่นอย่างไร

ผู้ให้บริการ	SMS ขาออกในสหรัฐฯ	SMS ขาเข้าในสหรัฐฯ	หมายเลขโทรศัพท์	ต้องมี 10DLC
Twilio	$0.0083 + ค่าธรรมเนียมผู้ให้บริการ	$0.0083 + ค่าธรรมเนียม	$1.15/เดือน	ใช่
Plivo	$0.005	$0.00035	$0.80/เดือน	ใช่
Telnyx	$0.004	$0.004	$1.00/เดือน	ใช่
Bird (MessageBird เดิม)	~$0.007	~$0.007	แตกต่าง	ใช่

Plivo และ Telnyx ราคาถูกกว่า โดยเฉพาะขาเข้าของ Plivo
Telnyx รวมค่าธรรมเนียมเครือข่ายในราคา (ตรวจสอบรายละเอียดแต่ละเจ้า)
Twilio เหนือกว่าด้านเอกสาร, integration, และ ecosystem

วิธีทดสอบ Twilio ฟรี

สมัครบัญชี Twilio ทดลองใช้งาน ไม่ต้องใช้บัตรเครดิต
ได้เครดิตเริ่มต้น ส่งข้อความจริงได้
ข้อความที่ส่งไปหมายเลขที่ยังไม่ยืนยันจะมี prefix "Sent from your Twilio trial account"
การทดลองใช้ฟรีเหมาะสำหรับ:
- จัดหาหมายเลขทดสอบ
- ส่ง/รับ SMS ผ่าน API
- ทดสอบ webhook ขาเข้า
- สำรวจ Twilio Console

เมื่ออัปเกรดบัญชีแบบชำระเงิน จะไม่มีข้อความ prefix และจ่ายเฉพาะที่ใช้จริง

วิธีทดสอบการเชื่อมต่อ Twilio SMS ของคุณด้วย Apidog

หลังตั้งค่า Twilio credentials และ webhooks แล้ว ควรตรวจสอบการเชื่อมต่อด้วยวิธีอัตโนมัติ:

Test Scenarios ใน Apidog ช่วยให้คุณ:

นำเข้า Twilio webhook endpoint spec โดยตรง
เพิ่มขั้นตอนแต่ละโฟลว์: ส่ง SMS, รับ callback, รับ inbound
ใช้ orchestrate เปลี่ยนลำดับขั้นตอนและรันตามลำดับ
ส่งค่าระหว่างขั้นตอนผ่าน {{$.stepId.response.body.field}} (เช่น Message SID)

ตัวอย่าง flow:

ส่งข้อความผ่าน Twilio API
รับ Message SID จาก response
ตรวจสอบ webhook callback รับ SID กลับมาตรงตาม spec

Contract Testing:

Apidog ตรวจสอบ response จริงกับ OpenAPI spec อัตโนมัติ
ยืนยัน HTTP status, ฟิลด์จำเป็น, ประเภทข้อมูล, ไม่มีฟิลด์เกิน
ใช้งานได้ทั้ง API call, debug, test, และอัตโนมัติ

เริ่มต้นใช้งาน:

ดาวน์โหลด Apidog ฟรี
นำเข้า Twilio API spec หรือกำหนด webhook schema
สร้างสถานการณ์ทดสอบที่สะท้อน flow การส่ง/รับ SMS ของคุณ

บทสรุป

Twilio SMS API เริ่มต้น $0.0083 ต่อส่วน (long code สหรัฐฯ) แต่ต้นทุนจริงรวมค่าธรรมเนียมเครือข่าย, ค่าเช่าหมายเลข, และค่าลงทะเบียน 10DLC ตัวอย่าง: ข้อความขาออก AT&T = $0.0118 ต่อส่วน ถ้ามีแคมเปญ 10DLC มาตรฐาน เพิ่ม $10/เดือน/แคมเปญ

ราคามีความโปร่งใสและเอกสารดี ส่วนลดตามปริมาณอัตโนมัติ แต่ควรพิจารณาทุกรายการต้นทุน ไม่ใช่แค่อัตราที่ headline

หลังประมาณต้นทุน: สร้าง connection และทดสอบให้ละเอียด

ใช้ Test Scenarios และ Contract Testing ของ Apidog ตรวจสอบ webhook flow และยืนยัน API response ตรงกับ spec โดยไม่ต้องเขียนโค้ดทดสอบซ้ำซ้อน

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

ถาม: ราคาพื้นฐานสำหรับ SMS ขาออกของสหรัฐฯ บน Twilio คือเท่าไร?

ตอบ: $0.0083 ต่อส่วน (long code สหรัฐฯ) บวกค่าธรรมเนียมเครือข่าย เช่น AT&T เพิ่ม $0.0035 รวมเป็น $0.0118 ต่อส่วน

ถาม: Twilio คิดค่าบริการสำหรับ SMS ขาเข้าหรือไม่?

ตอบ: คิด $0.0083 ต่อส่วน (long code/โทรฟรี) และอาจมีค่าธรรมเนียมเครือข่ายตามผู้ให้บริการ

ถาม: 10DLC คืออะไร และต้องจ่ายค่าบริการหรือไม่?

ตอบ: 10DLC คือระบบ registration สำหรับ A2P SMS บน long code สหรัฐฯ ต้องลงทะเบียนแบรนด์ ($4.50 ครั้งเดียว) และค่าธรรมเนียมแคมเปญ ($1.50–$10/เดือน)

ถาม: Twilio short code มีค่าใช้จ่ายเท่าไร?

ตอบ: Short code แบบสุ่ม $1,000/เดือน (รายไตรมาส) Short code เฉพาะ $1,500/เดือน ค่าตั้งค่า MMS $500

ถาม: Twilio มีส่วนลดตามปริมาณหรือไม่?

ตอบ: มีโดยอัตโนมัติ เริ่มลดราคาสำหรับข้อความเกิน 150,000 ต่อเดือน (ต่อประเภทหมายเลข) และมีส่วนลดสำหรับองค์กรโดยติดต่อฝ่ายขาย

ถาม: Twilio มีการทดลองใช้ฟรีหรือไม่?

ตอบ: มีบัญชีทดลองฟรีพร้อมเครดิต ไม่ต้องใช้บัตรเครดิต ข้อความทดลองมี prefix จนกว่าจะอัปเกรดบัญชี

ถาม: ทางเลือก Twilio ที่ถูกที่สุดสำหรับ SMS คืออะไร?

ตอบ: Plivo ($0.005) และ Telnyx ($0.004) ต่อข้อความ ราคาต่ำกว่า Twilio แต่ต้องลงทะเบียน 10DLC เช่นกัน Twilio เด่นกว่าด้านเอกสารและฟีเจอร์สำหรับ use case ซับซ้อน

ทดลองใช้ Apidog ได้เลย: ดาวน์โหลด Apidog ฟรี

ตรวจสอบ เชื่อมต่อ ทดสอบ Twilio SMS อย่างอัตโนมัติและมั่นใจใน production!

ราคา Vonage SMS API เท่าไหร่? (ราคาปี 2026)

Thanawat Wongchai — Fri, 03 Apr 2026 03:55:52 +0000

สรุปโดยย่อ

ราคา Vonage SMS API เริ่มต้นที่ $0.00809 ต่อข้อความขาออก และ $0.00649 ต่อข้อความขาเข้า ในสหรัฐอเมริกา ไม่มีค่าใช้จ่ายขั้นต่ำรายเดือน คุณจ่ายเฉพาะสิ่งที่ส่งและรับ อัตราค่าบริการระหว่างประเทศแตกต่างกันแต่ละประเทศ และบางตลาดอาจสูงกว่า $1.00 ต่อข้อความ หากคุณต้องการทดสอบการเชื่อมต่อ Vonage SMS, Apidog ช่วยให้คุณส่ง request ทดสอบ ตรวจสอบ response และแก้ไขข้อผิดพลาดก่อน deploy โค้ดจริง

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

บทนำ

ถ้าคุณเคยใช้ Nexmo คุณก็คือผู้ใช้งาน Vonage อยู่แล้ว Vonage เข้าซื้อ Nexmo ในปี 2016 โดย Nexmo คือแพลตฟอร์ม API สำหรับ SMS และ communications ที่โฟกัส developer ปัจจุบัน Vonage ยังคงใช้ developer.vonage.com เป็นศูนย์กลางเอกสารและ support และในปี 2022 Vonage ก็ถูกรวมเป็นส่วนหนึ่งของ Ericsson แต่ยังคงแบรนด์ Vonage เอาไว้สำหรับธุรกิจ API

ปัจจุบัน Vonage ให้บริการธุรกิจมากกว่า 100,000 ราย มีนักพัฒนาลงทะเบียน 1.6 ล้านคน ใช้ API ในการสร้างแอป เป็นแพลตฟอร์มแบบจ่ายจริงตามการใช้งาน (pay-as-you-go) ไม่มีสัญญาผูกมัด ใช้งานได้มากกว่า 190 ประเทศ

💡 ก่อนเชื่อมต่อ API จริง คุณควรมีเครื่องมือทดสอบ API ที่เชื่อถือได้ Apidog สามารถสร้าง test scenario สำหรับ Vonage SMS ตรวจสอบ response และจัดการ workflow API หลายรายการได้ในขั้นตอนเดียว ลองใช้ Apidog ฟรี ไม่ต้องใช้บัตรเครดิต

ภาพรวมราคา Vonage SMS

Vonage ใช้โมเดล pay-as-you-go สำหรับ SMS API ไม่มีค่าใช้จ่ายแพลตฟอร์มหรือ subscription รายเดือน เริ่มต้นใช้งานได้ทันที ดูราคาได้จากประเทศปลายทางและประเภทหมายเลข

ประเภทข้อความ	ราคาต่อข้อความ
SMS ขาออก (US LVN)	$0.00809
SMS ขาเข้า (US LVN)	$0.00649
SMS ขาออก (US Toll-Free)	ติดต่อฝ่ายขาย
SMS ขาเข้า (US Toll-Free)	ฟรี

LVN = Local Virtual Number (10DLC)
ราคาแต่ละประเทศแตกต่างกัน ดาวน์โหลดตารางราคาทั่วโลกจาก dashboard Vonage ได้

รายละเอียดราคา: ขาออก, ขาเข้า, MMS, และ WhatsApp

SMS ขาออก

ขาออก (US Local Virtual Number): $0.00809 ต่อข้อความ
อัตรานี้อัปเดตจากหน้าราคา Vonage (ต้นปี 2026)
ตรวจสอบอัตราปัจจุบันจากแดชบอร์ดเท่านั้น

SMS ขาเข้า

ขาเข้า (US LVN): $0.00649 ต่อข้อความ
หมายเลขโทรฟรีบางประเภทขาเข้าฟรี ตรวจสอบก่อนใช้งานจริง

ราคา MMS

รองรับ MMS ผ่าน Messages API
ไม่มีการประกาศราคาสาธารณะ ต้องติดต่อฝ่ายขาย

WhatsApp ผ่าน Vonage

WhatsApp มีค่าธรรมเนียม 2 ส่วน:

ค่าธรรมเนียมของ WhatsApp (Meta): คิดต่อข้อความและตามหมวดหมู่ แนะนำตรวจสอบ หน้าราคา WhatsApp ของ Meta
ค่าธรรมเนียม Vonage Platform: เริ่มต้น $0.00015 ต่อข้อความ

Facebook Messenger

Vonage คิด $0.0011 ต่อข้อความ ผ่าน Messages API

RCS (Rich Communication Services)

ผู้ให้บริการเครือข่าย	RCS Rich (ข้อความ)	RCS Rich Media
T-Mobile	$0.00620	$0.01250
Verizon	$0.00400	$0.00600
AT&T	$0.00450	$0.01000
US Cellular	$0.00620	$0.01350

ค่าตั้งค่าประเทศ: $600 ต่อประเทศ (จ่ายครั้งเดียว) สำหรับ RCS

ปัจจัยที่มีผลต่อบิล Vonage ของคุณ

ประเทศปลายทาง

SMS ที่ส่งไปสหรัฐฯ ราคาถูก
ส่งไปตลาดที่ coverage ต่ำ (แอฟริกา, SEA) อาจสูงถึง $0.50+ ต่อข้อความ
ตรวจสอบราคาก่อนวางแผนแคมเปญ

ประเภทหมายเลข

Long code (10DLC): ท้องถิ่น ถูกสุด เหมาะกับ P2P/A2P
Toll-free: ปริมาณสูง ขาเข้ามักฟรี
Short code: ปริมาณสูง ค่าเช่าแพง ต้องลงทะเบียนล่วงหน้า

ค่าเช่าหมายเลข

Long code US: สองสามดอลลาร์/เดือน
Toll-free/Short code: แพงขึ้น
คิดเพิ่มจากค่าข้อความ

การเข้ารหัสข้อความ

GSM-7: 160 ตัวอักษร/SMS
Unicode: 70 ตัวอักษร/SMS
ข้อความ Unicode 200 ตัว = 3 ข้อความ

ค่าธรรมเนียมเพิ่มเติมของผู้ให้บริการเครือข่าย

10DLC (A2P) มีค่าธรรมเนียม pass-through จากเครือข่าย
ดูรายละเอียดในใบแจ้งหนี้รายเดือน

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

ระดับการสนับสนุน

ฟรี: ฟอรัมและเอกสาร
ธุรกิจ/พรีเมียม: $3,300/เดือน (support 24/7)

API เสริม

ส่วนเสริม	ค่าใช้จ่ายรายเดือน
Audit API	$550/เดือน
Auto-redact (ลบ PII)	$1,100/เดือน
Reports API	$495/เดือน หรือ $0.00049/CDR

Audit API สำหรับองค์กรที่ต้องตาม compliance
Auto-redact สำหรับลบ PII อัตโนมัติ

ค่าใช้จ่าย Verify API

$0.0572 ต่อการยืนยันสำเร็จ รวม attempt ข้อความ/เสียง
Attempt ที่ไม่สำเร็จก็คิดค่าข้อความ

การลงทะเบียนหมายเลข (US 10DLC)

A2P SMS US: ต้องลงทะเบียนกับ The Campaign Registry (TCR)
Brand registration: ค่าธรรมเนียมครั้งเดียว
Campaign registration: ค่าธรรมเนียมรายเดือน/แคมเปญ

Vonage เทียบกับทางเลือกอื่น

ผู้ให้บริการ	SMS ขาออก US	SMS ขาเข้า US	ทดลองใช้ฟรี	การสนับสนุน
Vonage	$0.00809	$0.00649	ใช่ (เฉพาะเบอร์ยืนยันแล้ว)	ชำระเงิน; $3,300/เดือน สำหรับ 24/7
Twilio	$0.0079	$0.0075	ใช่ (เครดิต $15)	ชำระเงินเริ่ม $250/เดือน
Plivo	$0.0055	$0.0005	ใช่	ฟรีพื้นฐาน; มีชำระเงิน
Telnyx	$0.004	$0.002	ใช่ (เครดิต $5)	อีเมลฟรี 24/7; โทรศัพท์ชำระเงิน

ข้อสังเกต:

Telnyx ถูกสุดแต่ใหม่กว่า
Plivo ราคาขาเข้าแข่งได้
Twilio เอกสาร/ระบบนิเวศดีที่สุดแต่แพงกว่า
Vonage กลาง ๆ มีความสัมพันธ์กับผู้ให้บริการผ่าน Ericsson

วิธีทดลองใช้ Vonage ฟรี

ดูรายละเอียด Vonage Communications APIs Pricing:

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

หมายเลขเสมือน Vonage สำหรับ test
API key/secret พร้อมใช้งาน
เข้าถึงเอกสาร, SDKs
เครดิตทดลองส่งข้อความจำกัด

ข้อจำกัด

ส่งข้อความได้เฉพาะเบอร์ที่ยืนยันในบัญชีเท่านั้น (ป้องกัน fraud)
ส่งไปเบอร์อื่นต้องอัปเกรดบัญชี

วิธีเริ่มต้น

ไปที่ dashboard.nexmo.com หรือ vonage.com/communications-apis
สมัครบัญชีฟรีด้วยอีเมล
ยืนยันเบอร์โทรศัพท์
รับ API key/secret จาก dashboard
เรียก API แรกผ่าน REST API หรือ SDK

Vonage SDK รองรับ Node.js, Python, PHP, Ruby, Java, .NET, Go หรือจะเรียก REST API ตรงก็ได้

วิธีทดสอบการเชื่อมต่อ Vonage SMS ของคุณด้วย Apidog

เมื่อมี API key/secret แล้ว ควรทดสอบการเชื่อมต่อก่อนใช้งานจริง Apidog ออกแบบมาเพื่อให้ workflow นี้เป็นอัตโนมัติ

Test Scenarios ของ Apidog ช่วยให้เชื่อมโยง API requests หลายรายการเป็น workflow เดียว เช่น ส่ง SMS → ตรวจสอบสถานะส่ง → handle error

การตั้งค่าสถานการณ์ทดสอบ

ไปที่โมดูล Tests ใน Apidog แล้วสร้าง test scenario ใหม่
เพิ่มขั้นตอนจาก:
- Import จาก API spec (OpenAPI)
- เพิ่ม request เอง (Vonage REST API endpoint)
- Import cURL จากเอกสาร Vonage

ตัวอย่าง: ทดสอบส่ง SMS

เพิ่ม POST request ไปยัง https://rest.nexmo.com/sms/json
ใส่ API key, secret, from, to, text เป็น form params

การตรวจสอบการตอบกลับ

Apidog ตรวจสอบ response อัตโนมัติตาม schema ที่กำหนด

Vonage SMS API จะตอบกลับ JSON object ที่มี messages array
ใน array จะมี status ถ้า 0 คือสำเร็จ

Validation ที่ควรเพิ่ม:

HTTP status 200
messages[0].status == "0"
messages[0].message-id ต้องไม่ว่าง

ถ้ารหัสสถานะผิด Apidog จะแสดงสีแดงและโชว์ response ให้ debug

การส่งข้อมูลระหว่างคำขอ

ส่งค่าจาก response ของขั้นตอนก่อนหน้าไปยังขั้นตอนถัดไปได้ เช่น

{{$.stepId.response.body.messages[0].message-id}}

ใช้สำหรับ test workflow ที่ต้องใช้ message-id ตรวจสอบ delivery status

การรันทดสอบใน CI/CD

Apidog เชื่อมต่อกับ GitHub Actions, GitLab CI, Jenkins ได้

Export test scenario แล้ว run ผ่าน Apidog CLI
ตรวจสอบการเชื่อมต่อ SMS ทุกครั้งที่มี pull request

ทดลองใช้ฟรีที่ apidog.com ไม่ต้องใช้บัตรเครดิต

สรุป

Vonage SMS API คิดราคาตามการใช้งานจริง ไม่มีขั้นต่ำ ขาออก (US) $0.00809, ขาเข้า $0.00649 ค่าใช้จ่ายจริงขึ้นกับประเทศ, ประเภทหมายเลข, encoding และ feature พรีเมียม (Audit API, Auto-redact, 24/7 support) เพิ่มค่าใช้จ่ายรายเดือน ควรวางแผนงบประมาณให้เหมาะสม

ถ้าต้องการราคาถูกกว่า Telnyx/Plivo เป็นทางเลือก แต่ Vonage เหนือกว่าเรื่อง reliability และ global access สำหรับ enterprise โดยเฉพาะที่ต้องการ network support จาก Ericsson

ทดสอบ workflow SMS ทุกขั้นตอนก่อน production ด้วย Apidog สร้าง test scenario, validate response, แก้ไข error ตั้งแต่ dev stage

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

Vonage เหมือน Nexmo ไหม?

ใช่ Vonage ซื้อ Nexmo ในปี 2016 ใช้ platform และ API เดียวกัน developer.vonage.com/ rest.nexmo.com

Vonage มีค่ารายเดือน SMS หรือไม่?

ไม่มี คิดเฉพาะค่าข้อความและค่าเช่าหมายเลข ส่วนเสริมมีค่ารายเดือน

ค่าเช่าหมายเลข Vonage เท่าไหร่?

Long code US เริ่มต้นสองสามดอลลาร์ต่อเดือน Toll-free/Short code แพงกว่า ตรวจสอบใน dashboard

Vonage SMS รองรับประเทศไหน?

รองรับมากกว่า 190 ประเทศ ราคาต่างกัน โหลดตารางราคาใน dashboard

Vonage มีส่วนลดปริมาณการใช้งานไหม?

มี ถ้าปริมาณสูง ติดต่อฝ่ายขายเจรจาราคา

รับ SMS ขาเข้าได้ฟรีหรือไม่?

Toll-free US: ขาเข้าฟรี Long code US: $0.00649/ข้อความ ประเทศอื่นราคาต่างกัน

Vonage vs Twilio SMS?

Vonage ($0.00809) แพงกว่า Twilio ($0.0079) นิดเดียว Twilio เอกสาร/connection มากกว่า Vonage เหมาะกับ reliability/network support ผ่าน Ericsson ประสบการณ์ dev/support เป็นตัวตัดสิน

วิธีรัน Gemma 4 แบบ Local ด้วย Ollama: คู่มือฉบับสมบูรณ์

Thanawat Wongchai — Fri, 03 Apr 2026 02:55:12 +0000

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

Gemma 4 เปิดตัวเมื่อวันที่ 3 เมษายน 2026 และ Ollama v0.20.0 ได้เพิ่มการรองรับในวันเดียวกัน คุณสามารถดึงและรันโมเดลเริ่มต้น gemma4:e4b ได้ด้วยคำสั่งเพียงสองคำสั่ง คู่มือนี้จะแนะนำคุณเกี่ยวกับการตั้งค่า การเลือกโมเดล การใช้งาน API และวิธีทดสอบ Gemma 4 endpoints ในเครื่องของคุณด้วย Apidog

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

บทนำ

Google ได้เปิดตัว Gemma 4 เมื่อวันที่ 2 เมษายน 2026 ภายใน 24 ชั่วโมง Ollama ได้ออกเวอร์ชัน v0.20.0 พร้อมการรองรับเต็มรูปแบบสำหรับโมเดลทั้งสี่รูปแบบ

สำหรับนักพัฒนา Gemma 4 คือการอัปเกรดครั้งใหญ่: ทำคะแนน 89.2% ใน AIME 2026 เทียบกับ Gemma 3 ที่ได้ 20.8% และคะแนนการเขียนโค้ดเพิ่มจาก 110 ELO เป็น 2150 บน Codeforces คุณจะได้ฟีเจอร์ function calling, โหมดให้เหตุผลที่ปรับแต่งได้ และ context window สูงสุด 256K — ทั้งหมดนี้รันบนฮาร์ดแวร์ของคุณเอง

ถ้าคุณสร้างแอปที่ขับเคลื่อนด้วย API การรัน LLM ในเครื่องจะช่วยให้ได้เลเยอร์ AI ที่เร็วและปลอดภัยสำหรับ mock ข้อมูล, สร้าง test scenario, และตรวจสอบ API response โดยไม่ต้องส่งข้อมูลออกนอก

💡 เมื่อมี Gemma 4 ในเครื่องแล้ว Smart Mock ของ Apidog จะใช้ AI inference สร้าง mock API response ที่สมจริงจาก schema ของคุณโดยอัตโนมัติ แค่กำหนด API schema ครั้งเดียว Apidog จัดการ mock data ให้เอง เหมาะกับการทดลอง LLM ในเครื่องที่อยากได้ test data ตรง schema โดยไม่ต้องเขียน fixture เอง

คู่มือนี้จะสอนตั้งแต่การติดตั้งจนถึงการเรียกใช้งาน Gemma 4 API ในเครื่อง

มีอะไรใหม่ใน Gemma 4

Gemma 4 มีโมเดล 4 รุ่น ที่ตอบโจทย์ hardware และ use case ต่างกัน

จุดเด่นเมื่อเทียบกับ Gemma 3:

การให้เหตุผล/การเขียนโค้ด: 31B ทำคะแนน 80% ใน LiveCodeBench v6 (Gemma 3 27B ได้แค่ 29.1%)
Mixture-of-Experts (MoE): 26B ใช้ MoE เปิดใช้งานแค่ 4B parameters ต่อ inference คุณภาพใกล้เรือธงแต่เบาลงมาก
บริบทยาว: E2B/E4B รองรับ 128K tokens, 26B/31B รองรับ 256K
Function calling: ทุกโมเดลรองรับ native structured tool use รับ/คืน JSON ตรง schema โดยไม่ต้อง prompt engineering
รับอินพุตเสียง/รูป: E2B/E4B รองรับ input เสียงและรูปภาพ
Chain-of-Thought (CoT) mode: เปิด/ปิด reasoning per request ได้

คำอธิบายโมเดล Gemma 4 รุ่นต่างๆ

เลือกโมเดลให้เหมาะกับเครื่องของคุณ:

โมเดล	ขนาดบนดิสก์	บริบท	สถาปัตยกรรม	เหมาะสำหรับ
`gemma4:e2b`	7.2 GB	128K	Dense	แล็ปท็อป, edge, เสียง/รูป
`gemma4:e4b` (default)	9.6 GB	128K	Dense	นักพัฒนาส่วนใหญ่
`gemma4:26b`	18 GB	256K	MoE (4B active)	คุณภาพดีที่สุดต่อ GB
`gemma4:31b`	20 GB	256K	Dense	คุณภาพสูงสุด

e4b คือ default (ใช้ ollama run gemma4) เหมาะกับ GPU 10+GB VRAM หรือ Apple Silicon รวม 16GB RAM

26b (MoE) เหมาะกับ RAM 20+GB inference เร็วใกล้ 4B แต่คุณภาพเหมือน 13B

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

Ollama v0.20.0+ (เวอร์ชันก่อนหน้าไม่รองรับ Gemma 4)
ตรวจสอบเวอร์ชัน:

  ollama --version

อัปเดต Ollama:

  # macOS
  brew upgrade ollama

  # Linux
  curl -fsSL https://ollama.com/install.sh | sh

Windows: ดาวน์โหลดจาก ollama.com

Hardware:
- e2b: RAM 8GB+ (แนะนำ 16GB)
- e4b: VRAM 10GB หรือ Unified 16GB
- 26b: RAM/Unified 20GB+
- 31b: VRAM 24GB หรือ Unified 32GB

การติดตั้งและรัน Gemma 4

ดึงและรัน e4b (default):

ollama run gemma4

จะดาวน์โหลด ~9.6GB แล้วเข้าสู่ interactive prompt ลองพิมพ์:

>>> รหัสสถานะ HTTP สำหรับข้อผิดพลาดของไคลเอ็นต์คืออะไร?

รันรุ่นอื่น:

# Edge, ขนาดเล็ก
ollama run gemma4:e2b

# MoE (คุ้มคุณภาพ/ขนาด)
ollama run gemma4:26b

# Full flagship
ollama run gemma4:31b

ดึง model เฉยๆ (ไม่รัน):

ollama pull gemma4
ollama pull gemma4:26b

ลิสต์โมเดลที่มี:

ollama list

การใช้ Gemma 4 API ในเครื่อง

Ollama เปิด REST API ที่ http://localhost:11434 เรียกผ่าน HTTP client ได้เลย

สร้าง completion

curl http://localhost:11434/api/generate \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4",
    "prompt": "เขียนการตอบสนอง JSON สำหรับ API endpoint โปรไฟล์ผู้ใช้",
    "stream": false
  }'

แชทแบบ OpenAI-compatible

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4",
    "messages": [
      {
        "role": "user",
        "content": "สร้าง mock JSON ที่สมจริงสำหรับการตอบสนอง API คำสั่งซื้ออีคอมเมิร์ซ"
      }
    ]
  }'

ไคลเอนต์ Python

import requests

def ask_gemma4(prompt: str, model: str = "gemma4") -> str:
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "stream": False
        }
    )
    response.raise_for_status()
    return response.json()["response"]

result = ask_gemma4("แสดงรายการฟิลด์ที่การตอบสนอง API การชำระเงินควรรวมถึง")
print(result)

ใช้ OpenAI Python SDK

Ollama API compatible กับ OpenAI SDK:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # จำเป็นโดย SDK แต่ไม่ได้ใช้โดย Ollama
)

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {
            "role": "system",
            "content": "คุณสร้างข้อมูลการตอบสนอง API ที่สมจริงในรูปแบบ JSON"
        },
        {
            "role": "user",
            "content": "สร้างตัวอย่างการตอบสนองสำหรับ endpoint GET /users/{id}"
        }
    ]
)

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

การใช้ Function Calling กับ Gemma 4

Gemma 4 รองรับ function calling แบบ native แค่กำหนด schema function/tool โมเดลจะส่งคืน JSON ตรงลายเซ็นของคุณ:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_user",
            "description": "เรียกผู้ใช้ด้วย ID จาก API",
            "parameters": {
                "type": "object",
                "properties": {
                    "user_id": {
                        "type": "integer",
                        "description": "รหัสผู้ใช้ที่ไม่ซ้ำกัน"
                    },
                    "include_orders": {
                        "type": "boolean",
                        "description": "ว่าจะรวมประวัติคำสั่งซื้อหรือไม่"
                    }
                },
                "required": ["user_id"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {"role": "user", "content": "ดึงผู้ใช้ 42 พร้อมประวัติคำสั่งซื้อของเขา"}
    ],
    tools=tools,
    tool_choice="auto"
)

tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.function.name)       # get_user
print(tool_call.function.arguments)  # {"user_id": 42, "include_orders": true}

โมเดลจะ extract parameter ตรงจากภาษาไทยและคืน JSON ตาม schema ไม่ต้อง regex/parse output เอง

การเปิดใช้งานโหมดการคิด

เหมาะกับงานให้เหตุผลเชิงซับซ้อน เช่น test scenario หรือวิเคราะห์ API spec:

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {
            "role": "user",
            "content": "ออกแบบสถานการณ์การทดสอบที่สมบูรณ์สำหรับ API การประมวลผลการชำระเงินพร้อม edge cases"
        }
    ],
    extra_body={"think": True}
)

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

ถ้าแค่ mock ง่ายๆ ไม่ต้องเปิดโหมดนี้ (ลด latency)

การทดสอบการตอบสนอง Gemma 4 API ด้วย Apidog

เมื่อ Gemma 4 ในเครื่องทำงานแล้ว ทดสอบ endpoint ด้วย Apidog ได้ทันที

ขั้นตอน:

นำเข้าข้อกำหนด Ollama API: สร้างโปรเจกต์ใหม่ใน Apidog แล้วตั้ง base URL เป็น http://localhost:11434
กำหนด endpoint:
- POST /api/generate (completion)
- POST /v1/chat/completions (แชท)
- GET /api/tags (ลิสต์โมเดล)
ตั้ง test scenario:
1. GET /api/tags – เช็คว่า gemma4 อยู่ในโมเดล
2. POST /api/generate – ส่ง prompt แล้ว assert ว่า field response มีข้อมูล
3. POST /v1/chat/completions – ส่งแชทแล้วตรวจสอบว่าตรง format ที่ต้องการ

ใช้ Extract Variable ใน Apidog เพื่อ re-use response แต่ละ step ทดสอบ multi-turn flow ได้อัตโนมัติ

Contract Testing: เช็คว่า response ตรง OpenAPI spec ทุกครั้งหลังเปลี่ยน model
Smart Mock: กำหนด schema response ของ Gemma 4 แล้ว Smart Mock สร้าง mock data ให้ทีม front-end ใช้งานได้ทันที โดยไม่ต้องรอ LLM จริง

อินพุตแบบหลายโมดอลด้วย Gemma 4

E2B/E4B รับรูปภาพพร้อมข้อความ ส่งรูปเป็น base64 string:

import base64

with open("api_diagram.png", "rb") as f:
    image_data = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="gemma4:e4b",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{image_data}"
                    }
                },
                {
                    "type": "text",
                    "text": "อธิบายโฟลว์ API ที่แสดงในแผนภาพนี้และระบุเส้นทางข้อผิดพลาดที่อาจเกิดขึ้น"
                }
            ]
        }
    ]
)

เหมาะกับการวิเคราะห์ diagram, ตรวจสอบ screenshot docs, หรือดึงข้อมูลจากรูปภาพ (input multimodal)

ปัญหาและการแก้ไขทั่วไป

Ollama แจ้งว่าไม่พบโมเดล: รัน ollama pull gemma4 หรือดูด้วย ollama list
Inference ช้าบน CPU: ใช้ e2b (7.2GB) สำหรับเครื่องไม่มี GPU
หน่วยความจำไม่พอ: ตรวจสอบ VRAM/Unified RAM ด้วย ollama ps ถ้าไม่พอให้ใช้ e2b
โมเดลไม่โหลดบน Apple Silicon: Ollama 0.20.0 ขึ้นไปเท่านั้น
พอร์ต 11434 ถูกใช้: ตั้งค่าพอร์ตเอง OLLAMA_HOST=0.0.0.0:11435 ollama serve
Response ตัดทอน: เพิ่ม context window "options": {"num_ctx": 8192} ใน payload

Gemma 4 เทียบกับโมเดลในเครื่องอื่นๆ

โมเดล	ขนาดที่เหมาะกับผู้ใช้ทั่วไป	บริบท	Function Calling	Benchmark Coding
Gemma 4	e4b (9.6 GB)	128K-256K	Native	80% LiveCodeBench
Llama 3.3	70B-Q4 (40 GB)	128K	Native	~60% LiveCodeBench
Qwen3.6-Plus	72B-Q4 (44 GB)	128K	Native	แข็งแกร่ง
Mistral Small	24B (14 GB)	128K	Native	ปานกลาง

จุดเด่น: Gemma 4 26B (MoE) ขนาด 18GB คุณภาพใกล้ flagship แต่ inference เร็วกว่า dense ใหญ่ๆ เหมาะกับ dev ส่วนมาก

31B เหมาะกับงานโค้ด, e2b เหมาะกับ edge/laptop (<8GB RAM)

สรุป

Gemma 4 + Ollama คือ LLM ในเครื่องที่ทรงพลัง ติดตั้งง่ายมาก (ollama run gemma4) ใช้ API ได้ทันที คุณภาพการ reasoning และ code generation สูงกว่า Gemma 3 แบบก้าวกระโดด

เริ่มด้วย e4b ทดสอบ API ด้วย Apidog ให้ endpoints ทำงานครบ เลือกรุ่นที่เหมาะกับงานจากตารางข้างบน

ถ้าสร้างระบบ API บน Gemma 4 จับคู่ inference ในเครื่องกับ Smart Mock และ Test Scenario ของ Apidog จะช่วยให้ dev cycle เร็วและไม่ง้อ resource ภายนอก

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

Q: อัปเดต Gemma 4 ใน Ollama ได้อย่างไร?

A: รัน ollama pull gemma4 Ollama จะโหลดเฉพาะ patch ใหม่

Q: รันบนเครื่องไม่มี GPU ได้ไหม?

A: ได้ แต่ช้า (~1-3 tokens/sec) ควรใช้ e2b สำหรับเครื่อง CPU-only

Q: gemma4:e2b กับ gemma4:e4b ต่างกันยังไง?

A: ทั้งคู่เป็น dense, e4b ใหญ่กว่า reasoning ดีกว่า, e2b เล็ก/รองรับเสียง

Q: ใช้กับ LangChain/LlamaIndex ได้ไหม?

A: ได้ ทั้งคู่รองรับ Ollama ชี้ endpoint เป็น http://localhost:11434, ใช้ gemma4 เป็นชื่อโมเดล

Q: Ollama API ในเครื่อง compatible กับ OpenAI API ไหม?

A: ส่วนใหญ่แล้ว ใช้ /v1/chat/completions เปลี่ยน base_url เป็น http://localhost:11434/v1 ใส่ api_key เป็นอะไรก็ได้

Q: เปิดโหมดการคิดยังไง?

A: ส่ง "think": true ใน extra_body (OpenAI SDK) หรือ JSON ตรงๆ

Q: ให้ Gemma 4 บริการเครื่องอื่นใน network ได้ไหม?

A: ได้ รัน OLLAMA_HOST=0.0.0.0:11434 ollama serve แล้วเครื่องอื่นเรียกที่ IP/PORt นี้

Q: เลือกโมเดลไหนสำหรับพัฒนา API?

A: mock/test case — ใช้ e4b, วิเคราะห์ spec/arch ซับซ้อน — 26b (MoE) คุ้มกว่า 31b

หมายเหตุ: ลิงก์ที่เกี่ยวข้อง Apidog ในโพสต์นี้จะถูกติดตามด้วย UTM สำหรับ dev.to

วิธีใช้ Gemma 4 เป็น API Backend

Thanawat Wongchai — Fri, 03 Apr 2026 02:44:03 +0000

สรุป: Google เปิดตัว Gemma 4 ในเดือนเมษายน 2026 เป็นตระกูลโมเดลโอเพนซอร์ส 4 ขนาด ภายใต้ Apache 2.0 ประสิทธิภาพสูงกว่าคู่แข่งขนาดใหญ่กว่า 20 เท่าในการทดสอบมาตรฐาน สามารถเรียกใช้ Gemma 4 API ผ่าน Google AI Studio, Vertex AI หรือรันแบบโลคัลกับ Ollama/vLLM จับคู่กับ Smart Mock ของ Apidog เพื่อสร้าง API mock responses จาก OpenAPI schemas ได้โดยอัตโนมัติ ไม่ต้องเขียน mock rule แม้แต่ข้อเดียว

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

บทนำ

โมเดล AI โอเพนซอร์สมักบังคับให้คุณเลือกระหว่างความสามารถและการนำไปใช้งาน: โมเดลใหญ่เกินไปรันบนแล็ปท็อปไม่ได้ หรือเล็กเกินไปไม่เหมาะกับ reasoning หลายขั้นตอน Gemma 4 ทำลายข้อจำกัดนี้

Gemma 4 คือชุดโมเดลโอเพนซอร์สระดับสูงสุดของ Google DeepMind ขณะนี้ 31B Dense ติดอันดับ 3 บน Arena AI leaderboard เอาชนะคู่แข่งที่ใหญ่กว่า 20 เท่า 26B MoE อยู่ในอันดับ 6 ทั้งสองรันบน GPU 80GB เดียว ส่วน E2B/E4B ซึ่งเบากว่า สามารถรันออฟไลน์บนมือถือหรือ edge device ได้

สำหรับ dev API นี่คือจุดเปลี่ยน: Gemma 4 รองรับ function calling, structured JSON output และ context window 256K ในตัว ใช้งานจริงได้ในการสร้างเครื่องมือ API ด้วย AI ทั้งสร้าง test data, เขียน mocks, วิเคราะห์ API response

💡หากคุณสร้างด้วย Gemma 4 และต้องการตรวจสอบ response ที่สร้างโดย AI กับ OpenAPI spec, Smart Mock ของ Apidog สร้าง mock responses ตรง schema ได้อัตโนมัติ ไม่ต้องเขียน mock rule เลย Smart Mock อ่าน schema และสร้างข้อมูลที่เหมาะสมทันที ดาวน์โหลด Apidog ฟรีแล้วเชื่อมต่อ workflow Gemma 4 API ของคุณ

Gemma 4 คืออะไร และมีอะไรใหม่

Gemma 4 คือโอเพนซอร์ส LLM เจเนอเรชัน 4 ของ Google DeepMind “Gemma” แปลว่าอัญมณีในภาษาละติน เปิดตัวต้น 2024 นักพัฒนาดาวน์โหลดไปกว่า 400 ล้านครั้ง มี community “Gemmaverse” สร้างรูปแบบโมเดลหลากหลายกว่า 100,000 รายการ

Gemma 4 เปิดตัวภายใต้ Apache 2.0 license แตกต่างจากเวอร์ชันก่อนที่ใช้ custom usage term คุณสามารถใช้ ปรับแต่ง และนำไปใช้เชิงพาณิชย์ได้เต็มที่ เหมาะกับองค์กรหรือ startup ที่ต้องการควบคุม AI infra

จุดเด่นหลัก Gemma 4 คือ “intelligence-per-parameter” 31B Dense มีความสามารถสูงแต่ใช้ compute ต่ำกว่า GPT-4 หรือ Claude 3 Sonnet มาก บน Arena AI (เม.ย. 2026) Gemma 4 31B ดีกว่าโมเดล 600B parameter

ความใหม่เมื่อเทียบกับ Gemma 3:

อินพุต Multimodal (ดั้งเดิม): ประมวลผลภาพ/วิดีโอในตัว Edge E2B/E4B เพิ่ม input เสียง (voice) สำหรับ speech recognition (Gemma 3 ไม่มี)
Context Window ยาวขึ้น: E2B/E4B รองรับ 128K token, 26B/31B รองรับ 256K เพียงพอสำหรับส่ง codebase ทั้ง repo
Agentic Workflow Support: มี function calling, native JSON output, system instructions สร้าง agent ที่เรียก API, parse response, chain action ได้จริง
Advanced Reasoning: 31B ดีขึ้นมากด้าน math และ multi-step instruction เหมาะสำหรับสร้าง API test ที่ต้องเข้าใจ endpoint/schema relationship
รองรับกว่า 140 ภาษา: Pretrain มากกว่า 140 ภาษาโดยกำเนิด ไม่ใช่แค่ fine-tune จากอังกฤษ ใช้งานกับ API ทั่วโลกได้ทันที
Apache 2.0 License: ไม่มี legal ambiguity ใช้งานเชิงพาณิชย์ได้เต็มที่

Gemma 4 รุ่นย่อยและความสามารถ

Google เปิดตัว Gemma 4 สี่ขนาด เจาะกลุ่มฮาร์ดแวร์ต่างกัน:

โมเดล	พารามิเตอร์	พารามิเตอร์ที่ทำงานอยู่ (การอนุมาน)	บริบท	เหมาะที่สุดสำหรับ
E2B	2B ที่มีประสิทธิภาพ	~2B	128K	มือถือ, IoT, Edge ออฟไลน์
E4B	4B ที่มีประสิทธิภาพ	~4B	128K	โทรศัพท์, Raspberry Pi, Jetson Orin
26B MoE	26B รวม	~3.8B	256K	เซิร์ฟเวอร์ latency ต่ำ
31B Dense	31B	31B	256K	คุณภาพสูงสุด, วิจัย, Fine-tune

E2B/E4B ใช้ Mixture of Experts (MoE) เปิดใช้งาน parameter แค่บางส่วนต่อ token ประหยัด battery/RAM เหมาะกับ edge Google ร่วมมือ Qualcomm และ MediaTek, รันออฟไลน์บน Android ผ่าน AICore Dev Preview

26B MoE ใช้งานจริงแค่ 3.8B parameter inference, latency ต่ำ เหมาะกับ server-side

31B Dense คือผู้นำด้านคุณภาพ เหมาะกับ fine-tuning งานเฉพาะ หรือต้องการ structured JSON output ที่ซับซ้อน

ทั้งสี่รุ่นมี instruction-tuned (IT) และ base forms

สำหรับ API: 26B MoE สมดุล speed/quality, 31B Dense สำหรับ structured JSON และ multi-step logic

ทุกรุ่นรองรับ function calling และ JSON output mode เหมาะกับ dev API

การตั้งค่า Gemma 4 API: ทีละขั้นตอน

มี 3 ทางเลือกหลักในการใช้งาน Gemma 4: Google AI Studio (เร็ว), Vertex AI (องค์กร), หรือรันโลคัลด้วย Ollama/vLLM

ตัวเลือกที่ 1: Google AI Studio (แนะนำสำหรับโปรโตไทป์)

ไปที่ Google AI Studio สร้างบัญชีฟรี แล้วสร้าง API key
ติดตั้ง SDK:
```
pip install google-genai
```

ตัวอย่างเรียกใช้งาน:

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel("gemma-4-31b-it")

response = model.generate_content(
    "สร้างอ็อบเจกต์ JSON สำหรับบัญชีผู้ใช้ที่มีฟิลด์ id, email และ created_at"
)

print(response.text)

Structured JSON output:

import google.generativeai as genai
import json

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel(
    "gemma-4-31b-it",
    generation_config={"response_mime_type": "application/json"}
)

prompt = """
สร้าง 3 อ็อบเจกต์ผู้ใช้ตัวอย่างสำหรับ API อีคอมเมิร์ซ
ผู้ใช้แต่ละคนควรมี: id (จำนวนเต็ม), email (สตริง), username (สตริง),
created_at (การประทับเวลา ISO 8601), และ subscription_tier (free|pro|enterprise)
ส่งคืนเป็นอาร์เรย์ JSON
"""

response = model.generate_content(prompt)
users = json.loads(response.text)
print(json.dumps(users, indent=2))

ตัวเลือกที่ 2: การปรับใช้งานแบบโลคัลด้วย Ollama

ติดตั้ง Ollama จาก ollama.com
ดึงโมเดล:
```
ollama pull gemma4
```
รันเซิร์ฟเวอร์:
```
ollama serve
```

ใช้ API แบบ OpenAI-compatible:

import requests
import json

response = requests.post(
    "http://localhost:11434/api/chat",
    json={
        "model": "gemma4",
        "messages": [
            {
                "role": "user",
                "content": "สร้างการตอบกลับ JSON ที่ถูกต้องสำหรับ REST API /products endpoint. รวมถึงฟิลด์ id, name, price และ stock."
            }
        ],
        "stream": False
    }
)

result = response.json()
print(result["message"]["content"])

ตัวเลือกที่ 3: การเรียกใช้ฟังก์ชัน (Function Calling) สำหรับ API

Gemma 4 รองรับ function calling กำหนด function schema แล้วให้โมเดลเรียกใช้

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

tools = [
    {
        "function_declarations": [
            {
                "name": "get_api_schema",
                "description": "เรียกดู OpenAPI schema สำหรับเส้นทาง endpoint ที่กำหนด",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "endpoint_path": {
                            "type": "string",
                            "description": "เส้นทาง endpoint ของ API เช่น /users/{id}"
                        },
                        "method": {
                            "type": "string",
                            "enum": ["GET", "POST", "PUT", "DELETE", "PATCH"]
                        }
                    },
                    "required": ["endpoint_path", "method"]
                }
            }
        ]
    }
]

model = genai.GenerativeModel("gemma-4-31b-it", tools=tools)

response = model.generate_content(
    "ฉันต้องการทดสอบ GET /users/{id} endpoint Schema ที่การตอบกลับควรเป็นไปตามนั้นคืออะไร?"
)

if response.candidates[0].content.parts[0].function_call:
    fc = response.candidates[0].content.parts[0].function_call
    print(f"โมเดลเรียกใช้ฟังก์ชัน: {fc.name}")
    print(f"พร้อมอาร์กิวเมนต์: {dict(fc.args)}")

สามารถสร้าง agentic test pipeline สำหรับ API ได้จริง

การสร้าง API mocks ที่ขับเคลื่อนด้วย AI ด้วย Gemma 4

Gemma 4 เหมาะกับการสร้าง mock data สำหรับ dev API ตัวอย่าง: สร้าง mock response จาก OpenAPI schema

import google.generativeai as genai
import json

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel(
    "gemma-4-31b-it",
    generation_config={"response_mime_type": "application/json"}
)

schema = {
    "type": "object",
    "properties": {
        "id": {"type": "integer"},
        "order_number": {"type": "string", "pattern": "^ORD-[0-9]{6}$"},
        "status": {"type": "string", "enum": ["pending", "shipped", "delivered", "cancelled"]},
        "total": {"type": "number", "minimum": 0},
        "items": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "product_id": {"type": "integer"},
                    "quantity": {"type": "integer", "minimum": 1},
                    "unit_price": {"type": "number"}
                }
            }
        },
        "created_at": {"type": "string", "format": "date-time"}
    }
}

prompt = f"""
สร้าง 5 การตอบกลับจำลองที่สมจริงสำหรับ API การจัดการคำสั่งซื้อ
การตอบกลับแต่ละครั้งต้องเป็นไปตาม JSON Schema นี้อย่างเคร่งครัด:
{json.dumps(schema, indent=2)}

ทำให้ข้อมูลสมจริง: ใช้ราคาที่สมจริง, product IDs และสถานะที่หลากหลาย
ส่งคืนเป็นอาร์เรย์ JSON ของอ็อบเจกต์คำสั่งซื้อ 5 รายการ
"""

response = model.generate_content(prompt)
mock_orders = json.loads(response.text)
print(json.dumps(mock_orders, indent=2))

Gemma 4 เข้าใจ enum, string pattern, range ของ schema จริงๆ ได้ mock data ตรง schema ไม่ใช่แค่ string สุ่ม

ขยายได้กับ endpoint ไหนก็ได้ ป้อน schema response จาก OpenAPI ของคุณ Gemma 4 สร้าง test data ที่ตรง

ถ้าต้องการ conditional mock responses (เช่น ถ้ามี user ID ให้ส่ง error response) ใช้ context window 256K ที่ยาว: ป้อน OpenAPI spec ทั้งหมดใน prompt แล้วขอ mock หลาย endpoint พร้อมกัน

เวิร์กโฟลว์ที่แนะนำ: ส่งออก Apidog collection เป็น OpenAPI spec, วางใน prompt แล้วขอให้ Gemma 4 สร้าง test case สมจริงต่อ endpoint ได้ทันที

การทดสอบการตอบกลับ API ของ Gemma 4 ด้วย Apidog

เมื่อใช้ Gemma 4 สร้างข้อมูลหรือเป็นส่วนหนึ่งของ API pipeline ต้องตรวจสอบ response ว่าตรง schema หรือไม่ ใช้ Test Scenarios ของ Apidog

Workflow ที่แนะนำ:

นำเข้า Gemma 4 API endpoint เข้า Apidog สร้าง endpoint ใหม่ใน Apidog ตั้งค่า URL เป็น API wrapper Gemma 4 หรือชี้ไปยัง Google AI Studio endpoint กำหนด response schema ที่ต้องการ
ใช้ Smart Mock สร้าง prototype response ก่อนรันทดสอบจริง ใช้ Smart Mock ของ Apidog สร้าง mock response จาก schema ให้ทันที ฟิลด์ email จะถูก mock เป็น email จริง created_at จะเป็น timestamp อัตโนมัติ

Smart Mock มีลำดับชั้น: custom mock ก่อน, ตามชื่อ property, ตาม schema default คุณ override เฉพาะฟิลด์สำคัญแล้วปล่อยให้ engine จัดการส่วนที่เหลือ

สร้าง Test Scenario สำหรับ Gemma 4 pipeline ในโมดูล Tests ของ Apidog สร้าง Test Scenario ใหม่ เพิ่มการเรียก Gemma 4 API เป็นขั้นตอนแรก จากนั้น assertion ตรวจสอบ response
ตั้งค่า assertions ตรวจสอบ status code, header, ฟิลด์ JSON ใน response Gemma 4 มักจะยืนยัน candidates[0].content.parts[0].text ว่าตรง schema ที่กำหนด
Data-driven testing Apidog รองรับ CSV/JSON data file คุณเตรียม prompt หลากหลาย 50 แบบใน CSV แล้วรันทดสอบทั้งหมดได้ในคลิกเดียว ทดสอบ Gemma 4 กับ input หลากหลายได้จริง

ตั้งแต่ define schema ถึง execute test ใช้เวลาประมาณ 15 นาที หลังจากนั้นรันผ่าน Apidog CLI ใน CI/CD ได้เลย

กรณีการใช้งานจริง

สร้างข้อมูลทดสอบ API: ใช้ Gemma 4 + OpenAPI schema สร้าง test fixture หลายร้อย record ในไม่กี่นาที ป้อน schema ระบุ edge cases โมเดลสร้างข้อมูลให้
Smart API mocking: Mock แบบดั้งเดิมคือข้อมูลคงที่ Gemma 4 สร้าง context-aware mock ได้ เช่น API ค้นหาสินค้าส่งคืนสินค้าไม่ซ้ำตาม query โดยไม่ต้อง hardcode ทุกกรณี
สร้างเอกสาร API: ป้อน codebase ทั้งหมดใน context window 256K ขอให้ Gemma 4 สร้าง OpenAPI doc สำหรับ endpoint ที่ไม่มีเอกสาร Function calling ช่วยให้สร้าง agent เขียน spec อัตโนมัติ
API schema validation: ใช้ Gemma 4 วิเคราะห์ API response ตรวจ schema violation ช่วยตรวจจับ missing field, type ผิด, enum ไม่ตรง ดีกว่า JSON Schema validator ทั่วไป
เขียน regression test อัตโนมัติ: ป้อน API spec และ bug report ขอให้ Gemma 4 เขียน test case ตรวจแต่ละ bug เข้าใจ schema relationship สร้าง test ที่ซับซ้อนได้

Gemma 4 เทียบกับโอเพนซอร์สอื่นๆ สำหรับ API

เปรียบเทียบกับโมเดลโอเพนซอร์สชั้นนำอื่นๆ สำหรับงาน API

โมเดล	พารามิเตอร์	บริบท	เอาต์พุต JSON	การเรียกใช้ฟังก์ชัน	ใบอนุญาต
Gemma 4 31B	31B	256K	Native	Native	Apache 2.0
Gemma 4 26B MoE	26B (3.8B ที่ทำงานอยู่)	256K	Native	Native	Apache 2.0
Llama 3.3 70B	70B	128K	ผ่านพรอมต์	ผ่านพรอมต์	Llama Community
Mistral 7B	7B	32K	ผ่านพรอมต์	จำกัด	Apache 2.0
Qwen 2.5 72B	72B	128K	Native	Native	Apache 2.0

Gemma 4 31B/26B เด่นที่ native JSON output, function calling, context window ยาว

Llama 3.3 70B แข็งแกร่งแต่ต้องใช้ compute มากกว่า Gemma 4 31B ถึงสองเท่า และ Gemma 4 31B อยู่สูงกว่าใน Arena AI leaderboard แม้ขนาดเล็กกว่า

Mistral 7B ไวแต่ context window สั้น (32K) ขาด native JSON/function calling

Qwen 2.5 72B มีความสามารถ API tool เทียบเท่า Gemma 4 แต่ต้องการฮาร์ดแวร์ระดับสูงกว่า

Gemma 4 ได้เปรียบด้าน Apache 2.0 license (Llama มีข้อจำกัด commercial use)

สรุป: สำหรับ dev API ส่วนใหญ่ เริ่มที่ Gemma 4 26B MoE (latency ต่ำ) หรือ 31B (คุณภาพสูงสุด)

บทสรุป

Gemma 4 คือทางเลือกโอเพนซอร์สที่เหมาะสำหรับ API AI development ใบอนุญาต Apache 2.0 ทำให้ใช้ใน production/commercial ได้จริง รองรับ function calling และ JSON output ในตัว ไม่ต้อง prompt engineering เยอะ

ทั้ง 4 ขนาดครอบคลุมตั้งแต่มือถือถึง workstation 26B MoE คือจุด sweet spot สำหรับ dev API ส่วนใหญ่: คุณภาพใกล้เคียง LLM ชั้นนำ แต่ inference cost ต่ำ

จับคู่ Gemma 4 กับ Apidog เพื่อ workflow การสร้าง/ตรวจสอบ API ด้วย AI ใช้ Gemma 4 สร้าง test data, mock response ใช้ Smart Mock สร้าง prototype schema ใช้ Test Scenarios ตรวจสอบ output ว่าตรง API contract จริง

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

Gemma 4 คืออะไร? โมเดลภาษาโอเพนซอร์ส 4 ขนาดล่าสุดของ Google DeepMind เปิดตัว เม.ย. 2026 (E2B, E4B, 26B MoE, 31B Dense) Apache 2.0 31B Dense อยู่อันดับ 3 Arena AI leaderboard
Gemma 4 ใช้งานฟรีหรือไม่? ดาวน์โหลดน้ำหนักโมเดลใช้ฟรีตาม Apache 2.0 ใช้ compute เองเสียเฉพาะค่า hardware ถ้าใช้ Google AI Studio มี free tier (จำกัด rate) Vertex AI คิดตาม usage
Gemma 4 ส่งออก structured JSON ได้หรือไม่? ได้ รองรับ response_mime_type: "application/json" ใน Google Generative AI SDK บังคับให้ส่ง JSON ที่ parse ได้ทุกครั้ง
Gemma 4 เทียบกับ GPT-4o สำหรับ dev API ยังไง? GPT-4o เป็น proprietary, ไม่มี local deploy, ค่าใช้จ่าย API สูงกว่า Gemma 4 31B deploy local ฟรี คะแนน benchmark สูสี ถ้าต้องการ privacy/cost control Gemma 4 น่าสนใจ
Fine-tune Gemma 4 ด้วย API data ตัวเองได้หรือไม่? ได้ Fine-tune ผ่าน Google AI Studio, Vertex AI, หรือ Hugging Face TRL Fine-tune schema/response pattern เฉพาะ domain เพื่อ output คุณภาพสูงขึ้น
ฮาร์ดแวร์ที่ต้องใช้รัน Gemma 4 local? 31B/26B ใส่ใน NVIDIA H100 80GB (bfloat16) เวอร์ชัน quantized รันบน consumer GPU VRAM 16-24GB E4B/E2B รันบนโทรศัพท์/Edge/Raspberry Pi/NVIDIA Jetson
Gemma 4 รองรับ function calling หรือไม่? รองรับ ทุกรุ่น ใช้ JSON object กำหนด function schema ชื่อ/คำอธิบาย/parameter schema โมเดลตัดสินใจเรียก function และส่ง argument ที่ structured
ทดสอบ response Gemma 4 API อัตโนมัติได้ไหม? ใช้ Test Scenarios ของ Apidog สร้าง workflow test แบบ chain request/assertion รัน local ผ่าน CLI หรือใน CI/CD ทุก commit

Qwen3.6-Plus API: ชนะ Claude บน Terminal Benchmarks

Thanawat Wongchai — Thu, 02 Apr 2026 09:38:01 +0000

สรุป (TL;DR)

Qwen3.6-Plus เปิดตัวอย่างเป็นทางการแล้ว คะแนนสูงใน SWE-bench Verified 78.8% และ Terminal-Bench 2.0 ที่ 61.6% (สูงกว่า Claude Opus 4.5) พร้อม Context Window 1M โทเค็น มีพารามิเตอร์ใหม่ preserve_thinking สำหรับ Agent Loops และใช้งานกับ Claude Code, OpenClaw และ Qwen Code ได้โดยตรงผ่าน API ที่เข้ากันได้กับ OpenAI

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

จากการพรีวิวสู่การเปิดตัว

หากคุณเคยอ่าน คู่มือ Qwen 3.6 Plus Preview บน OpenRouter จะทราบถึงความสามารถของโมเดลนี้ รุ่นพรีวิวเปิดตัวเมื่อ 30 มีนาคม ประมวลผลโทเค็นไปกว่า 400 ล้านโทเค็นใน 2 วันแรก

ตอนนี้ Qwen3.6-Plus เปิดตัวอย่างเป็นทางการแล้ว ใช้งานได้ผ่าน Alibaba Cloud Model Studio มี API ที่เสถียร, uptime การันตี และพารามิเตอร์ใหม่ที่เหมาะกับงาน Agent หลายขั้นตอน

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

Qwen3.6-Plus คืออะไร

Qwen3.6-Plus เป็นโมเดล Mixture-of-Experts จากทีม Qwen ของ Alibaba ใช้ Sparse Activation (มีแค่บางส่วนของพารามิเตอร์ทำงานแต่ละโทเค็น) ช่วยให้มีประสิทธิภาพสูงแต่ต้นทุนต่ำกว่ารุ่น Dense

ฟีเจอร์หลัก:

Context Window 1M โทเค็น
Reasoning แบบ Chain-of-thought (บังคับใช้)
พารามิเตอร์ preserve_thinking สำหรับ Agent
รองรับ Multimodal (ภาพ, วิดีโอ, เอกสาร)
API compatible กับ OpenAI, Anthropic และ OpenAI Responses API

เวอร์ชัน Open-source ขนาดเล็กจะเปิดตัวเร็วๆ นี้ หากต้องการ Weights สำหรับ self-hosted ให้ติดตามข่าว

ผลลัพธ์ Benchmark

Coding Agents

Qwen3.6-Plus ตามหลัง Claude Opus 4.5 เพียงเล็กน้อยใน SWE-bench ส่วนใหญ่ แต่เป็นผู้นำทุกโมเดลใน Terminal-Bench

Terminal-Bench 2.0 ทดสอบ shell จริง เช่น การจัดการไฟล์ การควบคุมกระบวนการ และเวิร์กโฟลว์หลายขั้นตอน Qwen3.6-Plus ได้ 61.6% vs Claude Opus 59.3% เหนือกว่าอย่างชัดเจนในงานที่ developer ใช้งานจริง

General Agents และการใช้เครื่องมือ

Benchmark	Claude Opus 4.5	Qwen3.6-Plus
TAU3-Bench	70.2%	70.7%
DeepPlanning	33.9%	41.5%
MCPMark	42.3%	48.2%
MCP-Atlas	71.8%	74.1%
WideSearch	76.4%	74.3%

MCPMark ทดสอบการใช้เครื่องมือ GitHub MCP โดดเด่นที่ 48.2% DeepPlanning ที่ 41.5% เทียบกับ 33.9% ของ Claude แสดงความต่างในงานวางแผนยาว

การใช้เหตุผลและความรู้

Benchmark	Claude Opus 4.5	Qwen3.6-Plus
GPQA	87.0%	90.4%
LiveCodeBench v6	84.8%	87.1%
IFEval strict	90.9%	94.3%
MMLU-Pro	89.5%	88.5%

GPQA และ IFEval strict - Qwen3.6-Plus เป็นผู้นำ เหมาะกับ output มีโครงสร้างและงาน Agent ที่ต้องปฏิบัติตามข้อจำกัด

Multimodal

Qwen3.6-Plus เป็นโมเดล Multimodal แบบเนทีฟ นำหน้าในงานเอกสาร, spatial reasoning, object detection

Benchmark	Qwen3.6-Plus	หมายเหตุ
OmniDocBench 1.5	91.2%	อันดับสูงสุด
RefCOCO avg	93.5%	อันดับสูงสุด
We-Math	89.0%	อันดับสูงสุด
CountBench	97.6%	อันดับสูงสุด
OSWorld-Verified	62.5%	ตามหลัง Claude (66.3%)

สำหรับงานเอกสารและ spatial Qwen3.6-Plus เป็นผู้นำ

วิธีเรียกใช้ API

Qwen3.6-Plus มีบน Alibaba Cloud Model Studio รับ API key ได้ที่ modelstudio.alibabacloud.com

Base URLs:

สิงคโปร์: https://dashscope-intl.aliyuncs.com/compatible-mode/v1
ปักกิ่ง: https://dashscope.aliyuncs.com/compatible-mode/v1
สหรัฐอเมริกา เวอร์จิเนีย: https://dashscope-us.aliyuncs.com/compatible-mode/v1

การเรียกใช้พื้นฐานพร้อม Streaming

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["DASHSCOPE_API_KEY"],
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)

completion = client.chat.completions.create(
    model="qwen3.6-plus",
    messages=[{"role": "user", "content": "Review this Python function and find bugs."}],
    extra_body={"enable_thinking": True},
    stream=True
)

reasoning = ""
answer = ""
is_answering = False

for chunk in completion:
    if not chunk.choices:
        continue
    delta = chunk.choices[0].delta
    if hasattr(delta, "reasoning_content") and delta.reasoning_content:
        if not is_answering:
            reasoning += delta.reasoning_content
    if delta.content:
        if not is_answering:
            is_answering = True
        answer += delta.content
        print(delta.content, end="", flush=True)

พารามิเตอร์ preserve_thinking

ตั้งค่า preserve_thinking: true เพื่อให้โมเดลคง Chain-of-Thought จากทุกรอบก่อนหน้า เหมาะกับ Agent Loops หลายขั้นตอน (ปิดไว้โดย default เพื่อประหยัดโทเค็น)

completion = client.chat.completions.create(
    model="qwen3.6-plus",
    messages=conversation_history,
    extra_body={
        "enable_thinking": True,
        "preserve_thinking": True, # รักษา reasoning ทุกรอบ
    },
    stream=True
)

ใช้ Qwen3.6-Plus กับ Claude Code

Qwen API รองรับโปรโตคอล Anthropic แค่เปลี่ยน ENV ก็ใช้งาน Claude Code กับ Qwen3.6-Plus ได้ทันที

npm install -g @anthropic-ai/claude-code

export ANTHROPIC_MODEL="qwen3.6-plus"
export ANTHROPIC_SMALL_FAST_MODEL="qwen3.6-plus"
export ANTHROPIC_BASE_URL=https://dashscope-intl.aliyuncs.com/apps/anthropic
export ANTHROPIC_AUTH_TOKEN=your_dashscope_api_key

claude

ใช้ Qwen3.6-Plus กับ OpenClaw

OpenClaw (เดิม Moltbot / Clawdbot) เป็น Agent เขียนโค้ดแบบ self-hosted

# ติดตั้ง (Node.js 22+)
curl -fsSL https://molt.bot/install.sh | bash

export DASHSCOPE_API_KEY=your_key
openclaw dashboard

แก้ไข ~/.openclaw/openclaw.json เพิ่มฟิลด์ด้านล่าง:

{
  "models": {
    "providers": [{
      "name": "alibaba-coding-plan",
      "baseUrl": "https://coding-intl.dashscope.aliyuncs.com/v1",
      "apiKey": "${DASHSCOPE_API_KEY}",
      "models": [{"id": "qwen3.6-plus", "reasoning": true}]
    }]
  },
  "agents": {
    "defaults": {"models": ["qwen3.6-plus"]}
  }
}

ใช้ Qwen3.6-Plus กับ Qwen Code

Qwen Code เป็น Agent เทอร์มินัลแบบ Open-source จาก Alibaba ใช้ API ฟรี 1,000 ครั้ง/วันหลัง sign-in

npm install -g @qwen-code/qwen-code@latest
qwen
# พิมพ์ /auth เพื่อลงชื่อเข้าใช้และเปิดใช้งาน Free Tier

เหตุใด preserve_thinking จึงเปลี่ยนแปลงพฤติกรรมของ Agent

API LLM ทั่วไปจะไม่คง reasoning ข้ามแต่ละรอบ ทำให้ Agent หลุดประเด็นเมื่อต้องทำหลาย step

preserve_thinking จะเก็บ chain-of-reasoning ข้ามรอบ Agent เหมาะกับงานที่ต้องใช้ context reasoning หลายขั้นตอน

conversation = []

def agent_step(user_message, preserve=True):
    conversation.append({"role": "user", "content": user_message})

    response = client.chat.completions.create(
        model="qwen3.6-plus",
        messages=conversation,
        extra_body={
            "enable_thinking": True,
            "preserve_thinking": preserve,
        },
        stream=False
    )

    message = response.choices[0].message
    conversation.append({"role": "assistant", "content": message.content})
    return message.content

# ตัวอย่าง: Agent ตรวจสอบโค้ดแบบหลายขั้นตอน
result = agent_step("Analyze the auth module for security issues.")
result = agent_step("Now suggest fixes for the top 3 issues you found.")
result = agent_step("Write tests that validate each fix.")

ถ้าไม่มี preserve_thinking โมเดลจะไม่รู้ว่าขั้นที่ 1 เจอปัญหาอะไร แต่เมื่อเปิด reasoning chain จะไม่หลุด context

เหมาะสำหรับอะไรมากที่สุด

การแก้ไขข้อบกพร่องระดับ Repository: SWE-bench Verified 78.8% และ Pro 56.6%
ระบบอัตโนมัติสำหรับเทอร์มินัล: นำใน Terminal-Bench 2.0
การเรียกใช้เครื่องมือ MCP: MCPMark 48.2% (สูงสุด)
การวิเคราะห์เอกสารแบบ Long-context: Context Window 1M โทเค็น เหมาะกับ Codebase/Doc ขนาดใหญ่
Frontend code generation: QwenWebBench 1501.7 คะแนน ใกล้เคียง Claude Opus 4.5
หลายภาษา (Multilingual): WMT24++ 84.3%, MAXIFE 88.2% ครอบคลุม 23 ภาษา

การทดสอบการเรียกใช้ API ของ Qwen3.6-Plus ด้วย Apidog

Endpoint เข้ากันได้กับ OpenAI สามารถนำเข้าไปใน Apidog และทดสอบเหมือน API อื่นๆ

ตัวอย่างการตั้งค่า:

URL: https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions
Header: Authorization: Bearer {{DASHSCOPE_API_KEY}}

ตัวอย่าง Assertion ใน Apidog:

pm.test("Response contains choices", () => {
  const body = pm.response.json();
  pm.expect(body).to.have.property("choices");
  pm.expect(body.choices[0].message.content).to.be.a("string").and.not.empty;
});

pm.test("No empty reasoning when thinking enabled", () => {
  const choice = pm.response.json().choices[0];
  if (choice.message.reasoning_content !== undefined) {
    pm.expect(choice.message.reasoning_content).to.not.be.empty;
  }
});

ใช้ Smart Mock ของ Apidog เพื่อจำลอง response ระหว่างการพัฒนา ไม่ต้องเปลืองโทเค็นและทดสอบได้เร็ว

ถ้าสร้าง Agent หลายรอบ ให้สร้าง Test Scenario เชื่อมโยงหลาย request ตรวจสอบว่า preserve_thinking คง context reasoning ได้จริงก่อนนำไป production

ดาวน์โหลด Apidog ฟรี เพื่อตั้งค่าการทดสอบนี้

มีอะไรกำลังจะมา

ทีม Qwen เตรียมเปิดตัวเวอร์ชัน Open-source ขนาดเล็กในไม่กี่วัน (รูปแบบ Apache 2.0, Sparse MoE เหมือน Qwen3.5)

Roadmap ที่จะตามมา:

งานระดับ Repository กับไฟล์ขนาดใหญ่ขึ้น
Agent แบบ Multimodal ที่ควบคุม GUI และ Visual Coding เป็นความสามารถหลัก

หาก Qwen3.6 เหมือน Qwen3.5 เวอร์ชัน Open-source จะกลายเป็นตัวเลือกหลักสำหรับ self-hosted coding agent เร็วๆ นี้

สรุป

Qwen3.6-Plus ลดช่องว่างกับ Claude Opus 4.5 ในงานเขียนโค้ด นำในเทอร์มินัล, เครื่องมือ MCP, การวางแผนยาว Context Window 1M, Protocol Anthropic-compatible และ preserve_thinking เหมาะกับ Agentic System พร้อมใช้งานจริง

API อย่างเป็นทางการให้ความเสถียร SLA และฟีเจอร์ใหม่ที่เหมาะกับ Agent โดยเฉพาะ

Apidog ช่วยให้ทดสอบ API, Assertion, Mock และ Regression Test ได้สะดวกทุกครั้งที่อัปเดตโมเดลหรือ API

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

Qwen3.6-Plus และเวอร์ชันพรีวิวแตกต่างกันอย่างไร?

เวอร์ชันพรีวิว (qwen/qwen3.6-plus-preview) เปิดตัวบน OpenRouter เมื่อ 30 มี.ค. 2026 เวอร์ชันทางการเพิ่ม preserve_thinking, SLA และรองรับ Model Studio เต็มรูปแบบ เวอร์ชัน Open-source เล็กกว่ากำลังจะมา

preserve_thinking คืออะไร และควรใช้เมื่อใด?

โดยปกติ reasoning จะคงเฉพาะรอบปัจจุบัน ถ้าตั้งค่า preserve_thinking: true reasoning chain จะคงข้ามรอบ ใช้กับ Agent Loops หลายขั้นตอนที่ต้องเห็น reasoning เก่าด้วย

Qwen3.6-Plus เปรียบเทียบกับ Claude Opus 4.5 อย่างไร?

Claude Opus 4.5 นำใน SWE-bench Verified (80.9% vs 78.8%) และ OSWorld-Verified (66.3% vs 62.5%) แต่ Qwen3.6-Plus นำใน Terminal-Bench 2.0 (61.6% vs 59.3%), MCPMark (48.2% vs 42.3%), DeepPlanning (41.5% vs 33.9%) และ GPQA (90.4% vs 87.0%)

ฉันสามารถใช้ Qwen3.6-Plus กับ Claude Code ได้หรือไม่?

ได้ ตั้งค่า ANTHROPIC_BASE_URL ไปยัง Dashscope Anthropic endpoint, ANTHROPIC_MODEL เป็น qwen3.6-plus และ ANTHROPIC_AUTH_TOKEN เป็น Dashscope API key

Qwen3.6-Plus เป็น Open Source หรือไม่?

API โมเดลที่โฮสต์ไม่ใช่ Open-weight แต่เวอร์ชันเล็กกว่าและ Weights สาธารณะยืนยันแล้วว่าจะเปิดตัวเร็วๆ นี้

ฉันจะเข้าถึงได้ฟรีได้อย่างไร?

ติดตั้ง Qwen Code (npm install -g @qwen-code/qwen-code@latest), รัน qwen แล้ว /auth เพื่อ sign-in ด้วย Qwen Code OAuth รับสิทธิ์เรียก API ฟรี 1,000 ครั้ง/วัน

รองรับ Context Window ขนาดเท่าใด?

1 ล้านโทเค็นเป็นค่าเริ่มต้น บาง benchmark ใช้ 256K เพื่อมาตรฐานเปรียบเทียบ แต่ API default คือ 1M

ฉันจะทดสอบการผสาน API ก่อนปรับใช้งานจริงได้อย่างไร?

นำเข้า Endpoint ไปยัง Apidog, เพิ่ม API key เป็น env, เขียน Assertion และใช้ Smart Mock ระหว่างพัฒนา เชื่อมโยง request เป็น Test Scenario เพื่อตรวจสอบ Agent หลายรอบตั้งแต่ต้นจนจบ

Holo3: สุดยอดโมเดลการใช้งานคอมพิวเตอร์?

Thanawat Wongchai — Thu, 02 Apr 2026 08:57:54 +0000

สรุปโดยย่อ

H Company เปิดตัว Holo3 เมื่อวันที่ 31 มีนาคม 2026 ซึ่งเป็นโมเดล Mixture-of-Experts ที่ทำคะแนนได้ 78.85% ใน OSWorld-Verified ซึ่งเป็นคะแนนสูงสุดเท่าที่เคยบันทึกไว้ในเกณฑ์มาตรฐานการใช้งานคอมพิวเตอร์เดสก์ท็อปชั้นนำ มันเอาชนะ GPT-5.4 และ Opus 4.6 ได้ในราคาที่ถูกกว่ามาก API พร้อมใช้งานแล้ว และรุ่น 35B เป็นแบบโอเพนเวทบน HuggingFace ภายใต้ใบอนุญาต Apache 2.0

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

ช่องว่างในการใช้งานคอมพิวเตอร์ที่นักพัฒนาส่วนใหญ่ยังแก้ไม่ได้

แม้คุณจะทำ API automation ไปแล้ว CI/CD pipeline ก็ราบรื่น แต่งานบางอย่างยังคงเป็นจุดอ่อนของระบบอัตโนมัติ เช่น ซอฟต์แวร์องค์กรเก่าที่ไม่มี API, แอปเดสก์ท็อปยุคก่อน REST, หรือเวิร์กโฟลว์หลายขั้นตอนที่ต้องข้าม UI หลายตัว

RPA ดั้งเดิม (UiPath, Automation Anywhere) พึ่งพาสคริปต์พิกัดหน้าจอที่เปราะบางและมักเสียเมื่อ UI เปลี่ยน ทางเลือกคือการทำงานด้วยมือ

AI สำหรับการใช้งานคอมพิวเตอร์เปลี่ยนสมการนี้ — โมเดลที่ "มอง" ภาพหน้าจอและสั่งคลิก, พิมพ์, เลื่อน สามารถนำทาง GUI ใดก็ได้โดยไม่ต้องมี API Holo3 จาก H Company คือโมเดลที่แข็งแกร่งที่สุดในสายนี้ ณ ปัจจุบัน

💡 หากคุณสร้างเวิร์กโฟลว์อัตโนมัติหรือทดสอบ pipeline ที่เกี่ยวข้องกับซอฟต์แวร์เดสก์ท็อป API ของ Holo3 คือสิ่งที่ควรศึกษา และถ้าคุณใช้ Apidog เพื่อออกแบบ/ทดสอบ API ด้านล่างนี้จะแสดงวิธีเชื่อมการเรียก Holo3 เข้ากับเวิร์กโฟลว์ของคุณอย่างละเอียด

Holo3 คืออะไร?

Holo3 คือโมเดล AI สำหรับการใช้งานคอมพิวเตอร์: คุณส่งภาพหน้าจอของเดสก์ท็อปหรือเบราว์เซอร์, บอกงานที่ต้องการ, และโมเดลจะส่ง action (คลิก, กดแป้น, scroll) กลับมาให้ดำเนินการจริงบนหน้าจอ จับผลลัพธ์ ถ่ายภาพใหม่ วนลูปจนกว่างานเสร็จ

H Company มีสองรุ่นให้เลือก:

Holo3-122B-A10B — เรือธง, 122B parameters, ใช้งานจริง 10B (MoE แบบ sparse) API โฮสต์ที่ hcompany.ai/holo-models-api เท่านั้น
Holo3-35B-A3B — 35B parameters, ใช้งานจริง 3B, โอเพนเวทบน HuggingFace (Apache 2.0), มีบริการฟรีบน inference API, ติดตั้งเองได้

สถาปัตยกรรม MoE (mixture of experts) ช่วยลดต้นทุน inference H Company ระบุว่า Holo3-122B-A10B มีค่าใช้จ่ายน้อยกว่า GPT-5.4 และ Opus 4.6 ต่อหนึ่งงาน

OSWorld-Verified: เกณฑ์มาตรฐานนี้วัดผลอะไรจริงๆ

OSWorld-Verified เป็นเกณฑ์มาตรฐานชั้นนำสำหรับประเมิน AI การใช้งานคอมพิวเตอร์ เอเจนต์ต้องทำงานให้สำเร็จบนเครื่องจริง ผลลัพธ์ถูกตรวจสอบจากสถานะระบบจริงหลังจบงาน

งานครอบคลุม:

แอปเดียว (เปิดไฟล์, กรอกฟอร์ม, คัดลอกข้อมูล)
เวิร์กโฟลว์ข้ามแอป (ดึง PDF, อัปเดตสเปรดชีต, ส่งอีเมล)
ลำดับงาน multi-app ยาวๆ ที่ต้องการ reasoning ข้ามหลายระบบ

Holo3-122B-A10B ได้ 78.85% ใน OSWorld-Verified (โมเดลเดิมจาก Anthropic/OpenAI อยู่ที่ 60-65%)

H Company ยังระบุว่า Holo3 โดดเด่นในงาน multi-app ซึ่งต้องประสานข้อมูลข้ามหลายแอปพลิเคชัน

Holo3 ได้รับการฝึกฝนอย่างไร: Agentic Learning Flywheel

H Company พัฒนา Holo3 ด้วยวงจรฝึกฝนต่อเนื่อง:

Synthetic Navigation Data — สร้างตัวอย่างนำทางจากมนุษย์และ AI ตามสถานการณ์จริง
Out-of-Domain Augmentation — ขยายสถานการณ์เพื่อให้ครอบคลุม UI/edge case ที่ไม่คาดคิด
Curated Reinforcement Learning — คัดกรองแต่ละตัวอย่างแล้วนำไปใช้ใน RL pipeline เพื่อเพิ่มอัตราสำเร็จ

ข้อมูลฝึกฝนมาจาก Synthetic Environment Factory — ระบบที่ใช้เอเจนต์โค้ดสร้างแอปเว็บสมบูรณ์จากข้อกำหนด เพื่อให้โมเดลได้ฝึกบนเวิร์กโฟลว์ธุรกิจจริง

ผลลัพธ์: Holo3 มีประสิทธิภาพเหนือกว่าโมเดล Qwen3.5 ที่มี parameter มากกว่า บ่งชี้ว่าวิธีการฝึกสำคัญกว่าสถาปัตยกรรม

วิธีการเรียกใช้งาน Holo3 API

การใช้งาน Holo3 API คือการวนลูปจับภาพหน้าจอ-ดำเนินการ:

1. ตั้งค่าการยืนยันตัวตน

# H Company Inference API base URL
https://api.hcompany.ai/v1

# Header
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

รับ API key ได้ที่ hcompany.ai/holo-models-api (รุ่นฟรีสำหรับ Holo3-35B-A3B)

2. ส่งภาพหน้าจอพร้อมงาน

import base64
import httpx
import pyautogui

screenshot = pyautogui.screenshot()
screenshot.save("/tmp/screen.png")

with open("/tmp/screen.png", "rb") as f:
    image_b64 = base64.b64encode(f.read()).decode()

response = httpx.post(
    "https://api.hcompany.ai/v1/computer-use",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "model": "holo3-122b-a10b",
        "task": "Open the invoice folder and find the most recent PDF",
        "screenshot": image_b64,
        "screen_width": 1920,
        "screen_height": 1080
    }
)

action = response.json()
print(action)

3. แยกวิเคราะห์และดำเนินการ

API ส่ง action ที่มีโครงสร้าง เช่น:

{
  "action_type": "click",
  "coordinate": [245, 380],
  "reasoning": "The invoice folder icon is visible at this position"
}

ประเภท action: click, double_click, right_click, type, key, scroll, screenshot_request, task_complete

4. วนซ้ำจนกว่าจะเสร็จสมบูรณ์

def run_computer_use_task(task: str, max_steps: int = 20):
    for step in range(max_steps):
        screenshot = capture_screen()
        response = call_holo3_api(task, screenshot)
        action = response["action"]

        if action["action_type"] == "task_complete":
            print(f"Done in {step + 1} steps")
            return response["result"]

        execute_action(action)

    raise TimeoutError("Task not completed within step limit")

การทดสอบการเรียก Holo3 API ด้วย Apidog

หลังเชื่อม Holo3 API แล้ว ควรทดสอบ integration ให้มั่นใจว่าสามารถรันอัตโนมัติได้อย่างเสถียร Apidog คือเครื่องมือที่ตอบโจทย์นี้

นำเข้า Endpoint:

ใน Apidog สร้าง HTTP request ไปที่ https://api.hcompany.ai/v1/computer-use ใส่ Authorization header เป็นตัวแปรสภาพแวดล้อม

ตั้งค่าการตรวจสอบคำขอ:

ใช้ validation script ตรวจสอบโครงสร้าง response อัตโนมัติ

// ใน Apidog's post-response script
pm.test("Action type is valid", () => {
    const validActions = ["click", "type", "key", "scroll", "task_complete", "screenshot_request"];
    pm.expect(validActions).to.include(pm.response.json().action.action_type);
});

pm.test("Coordinates are within screen bounds", () => {
    const action = pm.response.json().action;
    if (action.coordinate) {
        pm.expect(action.coordinate[0]).to.be.within(0, 1920);
        pm.expect(action.coordinate[1]).to.be.within(0, 1080);
    }
});

จำลอง API ระหว่างพัฒนา:

ใช้ Smart Mock ของ Apidog เพื่อสร้าง response Holo3 จำลอง ไม่ต้องเปลืองเครดิตจริง

เรียกใช้สถานการณ์ทดสอบ:

เชื่อมต่อคำขอหลาย Holo3 ใน Apidog Test Scenario เพื่อจำลอง task หลายขั้นตอน ตรวจสอบลำดับ action ก่อนรันจริง

Holo3 เทียบกับ Claude Computer Use เทียบกับ OpenAI Operator

	Holo3-122B	Holo3-35B	Claude Computer Use	OpenAI Operator
OSWorld-Verified	78.85%	~55%	~65%	~62%
การเข้าถึง API	ใช่	ใช่ (ฟรี)	ใช่	ใช่
น้ำหนักแบบเปิด	ไม่	ใช่ (Apache 2.0)	ไม่	ไม่
สามารถโฮสต์เองได้	ไม่	ใช่	ไม่	ไม่
ราคาเทียบกับ GPT-5.4	ต่ำกว่า	ต่ำกว่ามาก	เทียบเคียงกัน	ราคา GPT-5.4
ดีที่สุดสำหรับ	องค์กรโปรดักชัน	dev/test/โอเพนซอร์ส	Anthropic ecosystem	OpenAI ecosystem

เลือกใช้งาน

Holo3-122B: แม่นยำสูงสุดสำหรับ multi-app workflow ซับซ้อน
Holo3-35B: เหมาะกับ dev, test, โอเพนซอร์ส, ต้องโฮสต์เอง
Claude Computer Use: สำหรับผู้ใช้ Anthropic API
OpenAI Operator: หากใช้ GPT-5.4 หรือ OpenAI stack

กรณีการใช้งานระดับองค์กร

Holo3 เหมาะกับเวิร์กโฟลว์ที่ API automation ไปไม่ถึง เช่น

ระบบเดิมไม่มี API: ERP/CRM เก่า, นำทาง UI อัตโนมัติ
กระทบยอดข้ามแพลตฟอร์ม: ดึง PDF → อัปเดตสเปรดชีต → อัปเดต dashboard
Regression Testing เว็บแอป: ไม่ต้องดูแล selector Selenium, ใช้ task ภาษาไทย/อังกฤษตรงๆ โมเดลจะปรับตาม UI
ข่าวกรองการแข่งขัน: ดึงข้อมูลจากเว็บที่บล็อกการสกรัปแบบเดิม

ผล benchmark ภายใน H Company ชี้ว่า Holo3 เด่นสุดใน workflow multi-app — จุดที่ต้อง reasoning ข้ามระบบ

ก้าวต่อไป: Adaptive Agency

H Company กำลังพัฒนา Adaptive Agency — โมเดลที่เรียนรู้ซอฟต์แวร์/ระบบใหม่แบบเรียลไทม์ แม้ไม่เคยเห็นมาก่อน

AI automation ปัจจุบัน (รวม Holo3) ยังฝึกจาก environment ที่จำกัด Adaptive Agency จะ reasoning โครงสร้างซอฟต์แวร์จาก zero-shot สร้าง model การทำงานเอง และดำเนินงานได้แบบอัตโนมัติเต็มที่

หากสำเร็จ ข้อจำกัดหลักของ AI เดสก์ท็อป automation จะหมดไป

สรุป

Holo3 เป็นมาตรฐานใหม่ของ AI สำหรับการใช้งานคอมพิวเตอร์เดสก์ท็อป ด้วยคะแนน 78.85% ใน OSWorld-Verified เหนือกว่า Claude และ GPT-5.x ชัดเจน โดยเฉพาะ multi-step workflow รุ่น 35B ฟรีและโอเพนเวท (Apache 2.0) เปิดโอกาสให้ dev ทดลองได้โดยไม่มีต้นทุน

การผสานรวม Holo3 API ทำได้ง่าย: จับภาพหน้าจอ, ส่ง POST, รับ action, execute, วนลูป Apidog ช่วยให้ integration น่าเชื่อถือ — ตรวจสอบ response, จำลองระหว่าง dev, chaining scenario ก่อน production

ถ้าคุณสร้างอะไรที่เกี่ยวกับ GUI เดสก์ท็อป ลองใช้ Apidog ฟรี และทดสอบ integration Holo3 ของคุณก่อนนำขึ้น production

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

Holo3 คืออะไร?

Holo3 คือโมเดล AI สำหรับการใช้งานคอมพิวเตอร์จาก H Company รับภาพหน้าจอเป็น input แล้วส่ง action (คลิก, พิมพ์, เลื่อน) กลับมาเพื่อทำ task บนเดสก์ท็อป/เบราว์เซอร์ ได้ 78.85% OSWorld-Verified (สูงสุดปัจจุบัน)

Holo3 เป็นโอเพนซอร์สหรือไม่?

Holo3-35B-A3B (รุ่นเล็ก) เป็นโอเพนเวท (Apache 2.0) ดาวน์โหลดได้จาก HuggingFace, Holo3-122B มีแค่ API ทั้งคู่เรียกผ่าน inference API H Company ได้ (35B มีฟรี)

เกณฑ์มาตรฐาน OSWorld ทำงานอย่างไร?

OSWorld ทดสอบ AI ด้วยงานคอมพิวเตอร์จริง เช่น นำทางเว็บ, จัดการไฟล์, เวิร์กโฟลว์ข้ามแอป ความสำเร็จวัดจากสถานะระบบจริงหลังเอเจนต์ทำงาน

Holo3 เปรียบเทียบกับ Claude Computer Use อย่างไร?

Holo3-122B คะแนน OSWorld-Verified สูงกว่า (78.85% vs ~65%) และค่าใช้จ่ายต่อภารกิจถูกกว่า Claude เหมาะกับผู้ใช้ Anthropic API

ฉันสามารถรัน Holo3 บนเครื่องของฉันเองได้หรือไม่?

ถ้าใช้ Holo3-35B-A3B ทำได้ (น้ำหนักอยู่ใน HuggingFace, Apache 2.0) Holo3-122B ใช้ API เท่านั้น

กรณีการใช้งานหลักสำหรับ API การใช้งานคอมพิวเตอร์คืออะไร?

automation ระบบเดิมไม่มี API
เวิร์กโฟลว์ข้อมูลข้ามแอป
regression test เว็บแอป (ไม่ต้องใช้ selector)
สกรัปข้อมูลเพื่อข่าวกรอง
งาน GUI เดสก์ท็อปที่ต้องใช้แรงคน

ฉันจะทดสอบการผสานรวม Holo3 API ของฉันได้อย่างไร?

ใช้ Apidog เพื่อนำเข้า endpoint, ตั้ง validation, mock API, และสร้าง test scenario ตรวจจับปัญหาก่อนรันจริง

"Adaptive Agency" ในแผนงานของ Holo3 คืออะไร?

คือเป้าหมายสร้างโมเดลที่นำทางซอฟต์แวร์องค์กรใหม่ได้แบบเรียลไทม์ reasoning UI โดยไม่ต้องฝึกมาโดยตรง — ลดข้อจำกัด AI automation ในองค์กรเฉพาะทาง

axios 1.14.1 โดนโจมตี: วิธีรับมือและป้องกัน

Thanawat Wongchai — Thu, 02 Apr 2026 08:52:18 +0000

สรุปโดยย่อ

ในวันที่ 30–31 มีนาคม 2026, axios เวอร์ชัน 1.14.1 และ 0.30.4 ถูกโจมตีบน npm ด้วยแพ็คเกจที่พึ่งพาซึ่งเป็นอันตราย และแพ็คเกจนั้นได้ติดตั้งโทรจันสำหรับเข้าถึงระยะไกล (RAT) บนเครื่องที่ติดเชื้อ ทั้งสองเวอร์ชันถูกถอนการเผยแพร่แล้ว เวอร์ชันที่ปลอดภัยคือ 1.14.0 หากคุณติดตั้ง axios@1.14.1 หรือ 0.30.4 ให้ถือว่าเครื่องของคุณถูกบุกรุกและเปลี่ยนข้อมูลประจำตัวทั้งหมดทันที

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

axios คืออะไร และทำไมเรื่องนี้ถึงสำคัญ

axios มีการดาวน์โหลด 100 ล้านครั้งต่อสัปดาห์บน npm เป็น HTTP client ที่ใช้ในเฟรมเวิร์กส่วนหน้าจำนวนนับไม่ถ้วน, บริการ Node.js ส่วนหลังบ้าน, และแอปพลิเคชันระดับองค์กร เมื่อแพ็คเกจที่เป็นรากฐานสำคัญขนาดนี้ถูกบุกรุก ผลกระทบก็มหาศาล — นักพัฒนาที่รัน npm install ในช่วงเวลาสั้นๆ ระหว่างวันที่ 30-31 มีนาคม ได้ดึงมัลแวร์เข้าสู่เครื่องของตนโดยไม่รู้ตัว

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

หากทีมของคุณใช้ axios และคุณใช้ Apidog เพื่อออกแบบและทดสอบการรวม HTTP client ของคุณ โปรดอ่านสิ่งนี้ก่อนการปรับใช้ครั้งถัดไป

ไทม์ไลน์ของการโจมตี

30 มีนาคม 2026 — 23:59:12 UTC: แพ็คเกจที่เป็นอันตรายชื่อ plain-crypto-js@4.2.1 ถูกเผยแพร่ไปยัง npm โดยบัญชีที่ใช้ nrwise@proton.me เวอร์ชันก่อนหน้า (4.2.0) ที่สะอาด ถูกเผยแพร่ไปเมื่อ 18 ชั่วโมงก่อนหน้านั้น โดยเป็นการสร้างชื่อที่คล้ายคลึงกับไลบรารี crypto-js ที่ถูกต้องเพื่อหลอกลวง (typosquat)

31 มีนาคม 2026 — 00:05:41 UTC: ระบบตรวจจับมัลแวร์อัตโนมัติของ Socket ได้ตั้งค่าสถานะ plain-crypto-js@4.2.1 ว่าเป็นอันตราย — เพียงหกนาทีหลังจากที่มันถูกเผยแพร่

31 มีนาคม 2026 — หลังเที่ยงคืนไม่นาน: axios@1.14.1 ถูกเผยแพร่ไปยัง npm โดยดึง plain-crypto-js@4.2.1 เป็นแพ็คเกจที่พึ่งพา การเผยแพร่ครั้งนี้ไม่ปรากฏในแท็กอย่างเป็นทางการของ GitHub repository ของ axios แท็กที่ถูกต้องล่าสุดยังคงเป็น v1.14.0

31 มีนาคม 2026 — เช้า: ปัญหา GitHub หมายเลข #10604 ถูกเปิดเผยต่อสาธารณะ โดยรายงานว่า axios@1.14.1 และ axios@0.30.4 ถูกบุกรุก ผู้ดูแล axios ยืนยันว่าในเบื้องต้นไม่สามารถเพิกถอนการเข้าถึงของผู้โจมตีได้ — บัญชีที่ถูกบุกรุกมีสิทธิ์ npm สูงกว่าผู้ดูแลที่ถูกต้องตามกฎหมาย

31 มีนาคม 2026: ทั้ง axios@1.14.1 และ axios@0.30.4 ถูกถอนการเผยแพร่จาก npm ผู้ดูแล axios เริ่มเพิกถอนโทเค็น, เพิ่มความเข้มงวดในการควบคุมการเผยแพร่, และกำลังตรวจสอบว่าโทเค็น npm ที่มีอายุการใช้งานยาวนานถูกใช้ประโยชน์อย่างไรเพื่อเข้าถึงการเผยแพร่โดยไม่ได้รับอนุญาต

การโจมตีทำงานอย่างไร

การโจมตีนี้ใช้ช่องโหว่ในขั้นตอนการเผยแพร่ของ axios: โทเค็น npm ที่มีอายุการใช้งานยาวนานที่เคยใช้ควบคู่กับการเผยแพร่ที่เชื่อถือได้ ผู้โจมตี — น่าจะหลังจากที่เจาะข้อมูลประจำตัวของผู้ดูแล — ใช้โทเค็นนี้เพื่อเผยแพร่เวอร์ชันใหม่นอกกระบวนการเผยแพร่ปกติ

เวอร์ชันใหม่ได้เพิ่ม plain-crypto-js@4.2.1 เป็นแพ็คเกจที่พึ่งพา ชื่อแพ็คเกจถูกออกแบบมาให้ดูเหมือนยูทิลิตีการเข้ารหัสที่ถูกต้องตามกฎหมาย; เวอร์ชัน 4.2.0 ที่สะอาดก่อนหน้านี้ถูกสร้างขึ้นเพื่อสร้างประวัติสั้นๆ เพื่อลดความสงสัย

ภายใน plain-crypto-js@4.2.1 การวิเคราะห์ของ Socket พบว่ามี เพย์โหลดแบบหลายขั้นตอน:

ขั้นตอนที่ 1 — การดำเนินการ: แพ็คเกจจะรันโค้ดเมื่อทำการติดตั้ง (ผ่านสคริปต์ npm lifecycle) เพื่อปล่อยเพย์โหลดรอง
ขั้นตอนที่ 2 — การติดตั้ง RAT: เพย์โหลดจะติดตั้งโทรจันสำหรับเข้าถึงระยะไกล (RAT) ที่เปิดแบ็คดอร์แบบถาวร
ขั้นตอนที่ 3 — การดึงข้อมูลออก: RAT สามารถรันคำสั่งเชลล์ใดๆ ที่ส่งมาจากเซิร์ฟเวอร์ C2, อ่านตัวแปรสภาพแวดล้อมและความลับจากระบบไฟล์, และส่งข้อมูลระบบออกไปทางเครือข่าย

RAT จะคงอยู่แม้หลังจากรีบูตเครื่อง ซึ่งหมายความว่าเครื่องที่ติดตั้งเวอร์ชันที่ถูกบุกรุกจะยังคงมีความเสี่ยงแม้ว่าจะลบแพ็คเกจ npm ออกไปแล้วก็ตาม เว้นแต่จะค้นหาและลบ RAT ออกไปอย่างชัดเจน

ฉันได้รับผลกระทบหรือไม่?

คุณอาจได้รับผลกระทบหาก:

คุณรัน npm install axios หรือ npm install (โดยมี axios อยู่ใน package.json) ระหว่างประมาณ 30 มีนาคม, 23:59 UTC ถึง 31 มีนาคม 2026 เที่ยง UTC
node_modules/axios/package.json ของคุณแสดงเวอร์ชัน 1.14.1 หรือ 0.30.4
package-lock.json หรือ yarn.lock ของคุณระบุ axios เป็น 1.14.1 หรือ 0.30.4

ตรวจสอบทันที:

# ตรวจสอบเวอร์ชันที่ติดตั้ง
npm list axios

# ตรวจสอบใน lock file
grep '"axios"' package-lock.json | head -5

# ตรวจสอบการมีอยู่ของ plain-crypto-js
npm list plain-crypto-js
ls node_modules/plain-crypto-js 2>/dev/null && echo "INFECTED" || echo "Not found"

หาก plain-crypto-js ปรากฏอยู่ใน node_modules ของคุณ แสดงว่าคุณได้รันเวอร์ชันที่เป็นอันตราย

สิ่งที่ต้องทำตอนนี้

1. อัปเดต axios ทันที

npm install axios@1.14.0
# หรือ pin ไปที่เวอร์ชันล่าสุดที่ปลอดภัย
npm install axios@latest

ตรวจสอบอีกครั้ง:

npm list axios
# ควรแสดง 1.14.0 หรือสูงกว่า (เมื่อมี clean 1.14.x ออก)

2. หากคุณติดตั้งเวอร์ชันที่ถูกบุกรุก

อย่าถือว่านี่เป็นแค่การอัปเดตแพ็คเกจที่พึ่งพา ให้ถือว่าเครื่องของคุณถูกบุกรุก:

เปลี่ยนความลับทั้งหมด ที่สามารถเข้าถึงได้จากเครื่องนั้น เช่น API key, ข้อมูลประจำตัวฐานข้อมูล, คีย์ SSH, โทเค็นคลาวด์, ตัวแปร .env
ตรวจสอบตัวแปรสภาพแวดล้อม — RAT มุ่งเป้าความลับใน environment และไฟล์ระบบ
ตรวจสอบการเชื่อมต่อเครือข่ายขาออก ในช่วงเวลาที่ได้รับผลกระทบ — มองหา connection ไปยัง IP แปลกๆ
สแกนหาความคงทน — ตรวจสอบ cron jobs, สคริปต์ startup, และ systemd service ที่ถูกเพิ่มในช่วงเวลานั้น
ติดตั้งอิมเมจใหม่ให้กับเครื่อง สำหรับ CI runner หรือ production server หากเป็น laptop นักพัฒนา ให้เปลี่ยนข้อมูลประจำตัวทั้งหมดก่อนถือว่าเครื่องสะอาด

3. ตรวจสอบ CI/CD Pipelines ของคุณ

หาก pipeline ของคุณรัน npm install ในช่วงเวลาดังกล่าว CI environment ของคุณอาจถูกบุกรุก ตรวจสอบดังนี้:

# ตรวจสอบ build logs สำหรับช่วงเวลาที่มีปัญหา
# มองหา axios@1.14.1 ใน output การติดตั้ง

# ตรวจสอบว่า node_modules ใน CI ปัจจุบันสะอาด
npm list axios plain-crypto-js

เปลี่ยนความลับที่ CI pipeline เข้าถึงได้ เช่น deployment keys, cloud provider credentials, registry tokens

4. ตรวจสอบไฟล์ lock ของคุณ

ไฟล์ lock (package-lock.json, yarn.lock) ควรระบุเวอร์ชันที่แน่นอน หาก lock file ของคุณมี 1.14.1 ให้สร้างใหม่:

# ลบและ regenerate
rm package-lock.json
npm install

ตรวจสอบ lock file ใหม่ว่าระบุ axios เป็นเวอร์ชันที่ปลอดภัยก่อน commit

การใช้ Apidog เพื่อตรวจสอบการเรียก API ของ axios ของคุณ

หากคุณใช้ axios เป็น HTTP client สำหรับการเรียก API, Apidog สามารถช่วยคุณยืนยันว่าการรวมของคุณยังคงส่งคำขอที่ถูกต้องหลังจากอัปเดตแพ็คเกจที่พึ่งพา

หลังจากอัปเดตเป็น axios@1.14.0 ให้นำเข้า API endpoints ที่มีอยู่ของคุณไปยัง Apidog และรัน regression test อย่างรวดเร็วเพื่อยืนยันว่าพฤติกรรมไม่เปลี่ยนแปลง การยืนยันการตอบกลับของ Apidog ช่วยให้คุณตรวจสอบค่าฟิลด์, เฮดเดอร์, และรหัสสถานะที่แน่นอนได้:

// Apidog post-response assertion
pm.test("Response is clean — no injected fields", () => {
    const body = pm.response.json();
    pm.expect(body).to.not.have.property('__injected');
    pm.expect(pm.response.headers.get('X-Injected-Header')).to.be.null;
});

รันชุดทดสอบทั้งหมดของคุณกับ axios รุ่นใหม่ใน Apidog จะช่วยให้คุณมี baseline ที่สะอาดก่อน deploy ขึ้น production

ลองใช้ Apidog ฟรีเพื่อตั้งค่าการทดสอบ HTTP client regression

ทำไมการโจมตี Supply Chain บน npm จึงยากที่จะหยุดยั้ง

การโจมตี axios ไม่ใช่กรณีแรก — นี่คือเหตุการณ์ supply chain ที่เคยเกิดขึ้น:

event-stream (2018): ผู้ดูแลที่เป็นอันตรายเพิ่มเพย์โหลดที่กำหนดเป้าหมายกระเป๋าเงิน Bitcoin
ua-parser-js (2021): ถูกบุกรุกเพื่อติดตั้ง cryptominer และขโมยรหัสผ่าน
node-ipc (2022): ผู้ดูแลจงใจเพิ่มโค้ดที่เป็นอันตรายซึ่งกำหนดเป้าหมาย IP ของรัสเซีย/เบลารุส
xz utils (2024): แคมเปญวิศวกรรมสังคมสองปีเพื่อแทรกแบ็คดอร์เข้าสู่ไลบรารีการบีบอัดหลักของ Linux
axios (2026): ข้อมูลประจำตัวของผู้ดูแลที่ถูกบุกรุกถูกใช้เผยแพร่ RAT ผ่านแพ็คเกจที่พึ่งพาซึ่งเป็นอันตราย

จุดร่วม: ความเชื่อถือในบัญชีผู้เผยแพร่ ไม่ใช่ในโค้ด หากข้อมูลประจำตัวของผู้ดูแลถูกบุกรุก ผู้โจมตีก็จะได้รับสิทธิ์เผยแพร่เช่นเดียวกับผู้ดูแลจริง

มาตรการที่ควรพิจารณา:
| มาตรการ | สิ่งที่ทำ |
|-------------------------------|-------------------------------------------------------------------|
| ไฟล์ Lock (package-lock.json) | ระบุเวอร์ชันที่แน่นอน, ป้องกันการอัปเกรดแบบไม่รู้ตัว |
| npm audit ใน CI | ตรวจจับช่องโหว่ที่ทราบก่อน deploy |
| Socket.dev / Snyk | วิเคราะห์พฤติกรรม — ตรวจจับแพ็คเกจที่น่าสงสัยแม้ไม่มี CVEs |
| 2FA บน npm | ทำให้การบุกรุกข้อมูลประจำตัวทำได้ยากขึ้น |
| โทเค็น publish ที่มีอายุสั้น | จำกัดช่วงเวลาเสี่ยงหากโทเค็นรั่วไหล |
| ตรวจ lock file ใน PR review | ตรวจสอบการเปลี่ยนแปลงแพ็คเกจที่พึ่งพาในการตรวจสอบโค้ด |

ทีม axios ยอมรับว่าโทเค็น npm ที่มีอายุการใช้งานยาวนานเป็นปัญหา และกำลังดำเนินมาตรการควบคุมการเผยแพร่ที่เข้มงวดขึ้น แต่การแก้ไขต้องมาจากระบบนิเวศโดยรวม ไม่ใช่แค่แพ็คเกจเดียว

ตัวบ่งชี้การบุกรุก (IOCs)

สรุปจากการวิเคราะห์ของ Socket:

แพ็คเกจที่เป็นอันตราย: plain-crypto-js@4.2.1, axios@1.14.1, axios@0.30.4
อีเมลผู้เผยแพร่: nrwise@proton.me
พฤติกรรม: มี network connection ตอนติดตั้ง npm, RAT คงทน, ดึง env variable
เวอร์ชัน axios ที่ปลอดภัย: 1.14.0 และต่ำกว่า (ยกเว้น 0.30.4), 1.13.x, 1.12.x

หากสงสัยว่าเครื่องติดเชื้อ ให้รายงานไปที่ security@npmjs.com และเก็บ log ไว้

สรุป

กรณี axios 1.14.1 ถูกบุกรุก เป็นเครื่องเตือนใจว่าสาย supply chain ต้องป้องกันตลอดเวลา — ล็อกเวอร์ชัน, ใช้เครื่องมือวิเคราะห์เช่น Socket ใน CI, เปลี่ยน credentials เมื่อมีสิ่งผิดปกติ, ตรวจ lock file เสมอในการ review

หากคุณต้องการสร้างความมั่นใจในการรวม API หลังอัปเดต axios, Apidog มีชุดทดสอบ, การยืนยัน, และ mock tools เพื่อยืนยันพฤติกรรม HTTP client ของคุณก่อน deploy

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

axios เวอร์ชันใดบ้างที่ถูกบุกรุก?

axios@1.14.1 และ axios@0.30.4 ถูกถอนการเผยแพร่จาก npm แล้ว เวอร์ชันที่ปลอดภัยคือ 1.14.0 (หรือ 1.13.x, 1.12.x)

เพย์โหลดที่เป็นอันตรายของ axios ทำอะไร?

มันดึง plain-crypto-js@4.2.1 ซึ่งติดตั้งเพย์โหลดแบบหลายขั้นตอนรวมถึง RAT ที่สามารถรันคำสั่งใดๆ จากเซิร์ฟเวอร์ C2, ดึง env และ secrets ออกไป, และคงอยู่แม้รีบูตเครื่อง

ฉันจะรู้ได้อย่างไรว่าฉันติดตั้งเวอร์ชันที่ถูกบุกรุก?

รัน npm list axios — หากแสดง 1.14.1 หรือ 0.30.4 แสดงว่าคุณได้รับผลกระทบ ตรวจสอบ npm list plain-crypto-js ด้วย — หากมี แสดงว่าโค้ดอันตรายรันไปแล้ว

การอัปเดต axios อย่างเดียวเพียงพอหรือไม่?

ไม่พอ RAT อาจคงอยู่ในเครื่องแล้ว ต้องเปลี่ยน secrets และตรวจหา persistence mechanism

ผู้โจมตีเผยแพร่ไปยัง npm ได้อย่างไรโดยที่ไม่ได้เป็นผู้ดูแล?

ผู้โจมตีอาจได้ credentials ของผู้ดูแลและใช้โทเค็น npm ที่มีอายุยาวซึ่งมีสิทธิ์ publish

ความแตกต่างระหว่างสิ่งนี้กับช่องโหว่ทั่วไปคืออะไร?

ช่องโหว่คือ bug ในโค้ดปกติ การโจมตี supply chain คือการแทรกโค้ดอันตรายผ่านช่องทาง publish ที่เชื่อถือได้ โค้ดอันตรายไม่เคยอยู่ใน GitHub — มันถูก inject ใน npm publish

ฉันจะปกป้องโปรเจกต์ของฉันจาก supply chain attack ได้อย่างไร?

ใช้ lock file, รัน npm audit ใน CI, วิเคราะห์พฤติกรรมด้วย Socket.dev, เปิด 2FA ใน npm, ใช้โทเค็น publish ที่อายุสั้น, ตรวจ lock file diff ใน code review

Microsoft VibeVoice คืออะไร? วิธีใช้โมเดล AI เสียงโอเพนซอร์ส

Thanawat Wongchai — Thu, 02 Apr 2026 08:23:53 +0000

สรุปย่อ

VibeVoice คือชุดโมเดล AI เสียงโอเพนซอร์สจาก Microsoft ประกอบด้วย 3 โมเดลหลัก: VibeVoice-1.5B สำหรับแปลงข้อความเป็นคำพูด (TTS), VibeVoice-Realtime-0.5B สำหรับ TTS แบบสตรีมมิ่ง, และ VibeVoice-ASR สำหรับรู้จำคำพูด (ASR) ทั้งหมดรันแบบโลคอล ติดตั้งใช้งานง่าย และมี API สำหรับการรวมเข้ากับระบบของคุณ คู่มือนี้สรุปวิธีติดตั้ง การเรียกใช้งานจริง และการทดสอบ API

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

บทนำ

Microsoft ได้เปิดตัว VibeVoice ในปี 2026 เป็นเฟรมเวิร์ก AI เสียงโอเพนซอร์สที่รวมทั้งโมเดลสังเคราะห์เสียงและรู้จำเสียง สามารถรันบนเครื่องของคุณเองโดยไม่ต้องใช้คลาวด์

เฟรมเวิร์กนี้ประกอบด้วย:

VibeVoice-1.5B: สร้างเสียงสนทนาหลายผู้พูด มีอารมณ์ ครอบคลุมสูงสุด 90 นาที รองรับ 4 ผู้พูด
VibeVoice-Realtime-0.5B: TTS แบบสตรีมมิ่ง หน่วงต่ำมาก (300ms)
VibeVoice-ASR: ถอดความเสียงต่อเนื่องสูงสุด 60 นาที, รองรับ 50+ ภาษา, พร้อมระบุผู้พูด

หลังเปิดตัวมีการควบคุมการใช้โค้ดเพื่อป้องกัน deepfake โดยเสียงที่สร้างจะมีคำเตือนฝังในเสียง และลายน้ำที่ตรวจสอบได้ โมเดล ASR มีให้ใช้งานบน Azure AI Foundry ส่วน TTS ใช้ใบอนุญาต MIT เน้นงานวิจัย

คู่มือนี้จะสอนการติดตั้ง การสร้างเสียง การรู้จำเสียง การรวม API และการทดสอบปลายทางด้วย Apidog

VibeVoice ทำงานอย่างไร: ภาพรวมสถาปัตยกรรม

ความก้าวหน้าของ Tokenizer

จุดเด่นคือ Tokenizer เสียงต่อเนื่องที่ใช้ sampling rate ต่ำมาก 7.5 Hz (เมื่อเทียบกับ 50-100 Hz ของระบบทั่วไป) ทำให้จัดการเสียงยาว (90 นาที) ได้โดยไม่หมดบริบท

ประกอบด้วย Tokenizer สองส่วน:

Acoustic Tokenizer: sigma-VAE, ลด sampling rate 3,200 เท่าจาก 24kHz
Semantic Tokenizer: โครงสร้างคล้ายกัน เน้นจับความหมายเชิงภาษา

การแพร่กระจายของโทเค็นถัดไป

โมเดลใช้ LLM (Qwen2.5-1.5B) ร่วมกับ Diffusion Head (123M พารามิเตอร์) โดย LLM จัดการบริบท ส่วน Head สร้างรายละเอียดเสียงด้วย DDPM

แนวทางการฝึกอบรม

ฝึกแบบ curriculum learning: เริ่มจากลำดับสั้น ขยายเป็น 4K, 16K, 32K, 64K token โดย tokenizer คงที่ อัปเดตเฉพาะ LLM และ Diffusion Head

ข้อมูลจำเพาะของโมเดล VibeVoice

โมเดล	พารามิเตอร์	วัตถุประสงค์	ความยาวสูงสุด	ภาษา	ใบอนุญาต
VibeVoice-1.5B	3B	ข้อความเป็นคำพูด	90 นาที	อังกฤษ, จีน	MIT
VibeVoice-Realtime-0.5B	~0.5B	TTS แบบสตรีมมิ่ง	ระยะยาว	อังกฤษ, จีน	MIT
VibeVoice-ASR	~9B	การรู้จำคำพูด	60 นาที	50+ ภาษา	MIT

VibeVoice-1.5B (TTS)

ข้อมูลจำเพาะ	ค่า
LLM พื้นฐาน	Qwen2.5-1.5B
ความยาวบริบท	64K โทเค็น
จำนวนผู้พูดสูงสุด	4 คน
เอาต์พุตเสียง	24kHz WAV โมโน
ประเภท Tensor	BF16
รูปแบบ	Safetensors

VibeVoice-ASR

ข้อมูลจำเพาะ	ค่า
สถาปัตยกรรมพื้นฐาน	Qwen2.5
พารามิเตอร์	~9B
ประมวลผลเสียงสูงสุด	60 นาที
อัตราเฟรม	7.5 Hz
WER เฉลี่ย	7.77%
ภาษา	50+
เอาต์พุต	โครงสร้าง (ใคร/เมื่อไหร่/อะไร)
รองรับไฟล์เสียง	WAV, FLAC, MP3 16kHz+

การติดตั้งและตั้งค่า

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

Python 3.8+
NVIDIA GPU รองรับ CUDA
VRAM 7-8 GB สำหรับ TTS, 24 GB+ สำหรับ ASR
RAM 32 GB (64 GB แนะนำสำหรับ ASR)
CUDA 11.8+ (แนะนำ 12.0+)

ติดตั้ง VibeVoice TTS

git clone https://github.com/microsoft/VibeVoice.git
cd VibeVoice
pip install -r requirements.txt

โมเดลจะดาวน์โหลดอัตโนมัติเมื่อรันครั้งแรก หรือดาวน์โหลดล่วงหน้าด้วย:

from huggingface_hub import snapshot_download

snapshot_download(
    "microsoft/VibeVoice-1.5B",
    local_dir="./models/VibeVoice-1.5B",
    local_dir_use_symlinks=False
)

ติดตั้งผ่าน pip (แพ็คเกจชุมชน)

pip install vibevoice

ติดตั้งสำหรับ ASR

git clone https://github.com/microsoft/VibeVoice.git
cd VibeVoice
pip install -r requirements-asr.txt

หรือใช้บน Azure AI Foundry สำหรับ inference คลาวด์

การสร้างเสียงพูดด้วย VibeVoice-1.5B

สร้างเสียงพูดจากผู้พูดคนเดียว

เตรียมไฟล์ข้อความ:

Alice: Welcome to the Apidog developer podcast. Today we're covering API testing strategies for 2026.

รันคำสั่ง:

python VibeVoice \
  --model_path microsoft/VibeVoice-1.5B \
  --txt_path script.txt \
  --speaker_names Alice \
  --cfg_scale 1.5

เอาต์พุตจะได้ไฟล์ .wav ในโฟลเดอร์ outputs/

สร้างพอดแคสต์หลายผู้พูด

รองรับสูงสุด 4 ผู้พูด:

Alice: Welcome back to the show. Today we have two API experts joining us.
Bob: Thanks for having me. I've been working on REST API design patterns for the past five years.
Carol: And I focus on GraphQL performance optimization. Happy to be here.
...

python VibeVoice \
  --model_path microsoft/VibeVoice-1.5B \
  --txt_path podcast_script.txt \
  --speaker_names Alice Bob Carol \
  --cfg_scale 1.5

การโคลนเสียง (Zero-shot)

ไฟล์อ้างอิง:

.wav (โมโน), 24kHz, 30–60 วินาที

แปลงไฟล์:

ffmpeg -i source_recording.m4a -ar 24000 -ac 1 reference_voice.wav

เปิด Gradio demo UI:

python demo/gradio_demo.py

แล้วอัปโหลดเสียง/โคลนเสียงที่ UI: http://127.0.0.1:7860

สตรีมด้วย VibeVoice-Realtime-0.5B

python demo/streaming_inference_from_file.py \
  --model_path microsoft/VibeVoice-Realtime-0.5B \
  --txt_path script.txt \
  --speaker_name Alice

Realtime เหมาะกับงานโต้ตอบสด, ความเที่ยงตรงน้อยกว่า 1.5B แต่เร็วกว่า

การใช้ VibeVoice กับ Python

Pipeline API

from transformers import pipeline
from huggingface_hub import snapshot_download

model_path = snapshot_download("microsoft/VibeVoice-1.5B")

pipe = pipeline(
    "text-to-speech",
    model=model_path,
    no_processor=False
)

script = [
    {"role": "Alice", "content": "How do you handle API versioning?"},
    {"role": "Bob", "content": "We use URL path versioning. v1, v2, and so on."},
]

input_data = pipe.processor.apply_chat_template(script)

generate_kwargs = {
    "cfg_scale": 1.5,
    "n_diffusion_steps": 50,
}

output = pipe(input_data, generate_kwargs=generate_kwargs)

FastAPI wrapper สำหรับการใช้งานจริง

มี FastAPI wrapper ให้เรียกใช้งาน API แบบ OpenAI-compatible:

git clone https://github.com/ncoder-ai/VibeVoice-FastAPI.git
cd VibeVoice-FastAPI
docker compose up

ทดสอบ API:

curl -X POST http://localhost:8000/v1/audio/speech \
  -H "Content-Type: application/json" \
  -d '{
    "model": "vibevoice-1.5b",
    "input": "Your API documentation should be a conversation, not a monologue.",
    "voice": "alice"
  }' \
  --output speech.wav

API นี้สามารถทดสอบผ่าน Apidog ได้ทันทีด้วยฟอร์แมตเดียวกับ OpenAI TTS API

การใช้ VibeVoice-ASR สำหรับการรู้จำคำพูด

ถอดความเบื้องต้น

python asr_inference.py \
  --model_path microsoft/VibeVoice-ASR \
  --audio_path meeting_recording.wav

เอาต์พุตที่มีโครงสร้าง

ASR ออกผลลัพธ์แบบ:

{
  "segments": [
    {
      "speaker": "Speaker 1",
      "start": 0.0,
      "end": 4.2,
      "text": "Let's review the API endpoints for the new release."
    },
    ...
  ]
}

ASR เป็นเซิร์ฟเวอร์ MCP

pip install vibevoice-mcp-server
vibevoice-mcp serve

เชื่อมต่อกับ Claude Code, Cursor หรือ AI coding tools อื่น ๆ ได้โดยตรง

เมื่อใดควรใช้ VibeVoice-ASR เทียบกับ Whisper

กรณีใช้งาน	ตัวเลือกที่ดีที่สุด	เหตุผล
ประชุมยาว (30-60 นาที)	VibeVoice-ASR	ประมวลผล 60 นาที, ระบุผู้พูด
สัมภาษณ์หลายผู้พูด	VibeVoice-ASR	แยกผู้พูดอัตโนมัติ
พอดแคสต์ต้องการ timestamp	VibeVoice-ASR	เอาต์พุตโครงสร้าง ใคร/เมื่อ/อะไร
เนื้อหาหลายภาษา (50+ ภาษา)	VibeVoice-ASR	รองรับหลายภาษากว่า
คลิปสั้น/เสียงรบกวนมาก	Whisper	ทนเสียงรบกวนดีกว่า
ติดตั้ง edge/mobile	Whisper	ขนาดเล็ก รองรับอุปกรณ์หลากหลาย
ภาษาเฉพาะทาง (ไม่ใช่อังกฤษ)	Whisper	ปรับแต่งหลายภาษาได้ดีกว่า

การทดสอบ Voice AI API ด้วย Apidog

Apidog ช่วยทดสอบและ debug การรวม API Voice AI ได้อย่างรวดเร็ว ไม่ว่าจะเป็น FastAPI wrapper, Azure AI Foundry หรือ API ของคุณเอง

ทดสอบปลายทาง TTS

สร้าง POST request ใหม่ใน Apidog ไปยัง VibeVoice FastAPI server
ตั้งค่า body เป็น JSON:

{
  "model": "vibevoice-1.5b",
  "input": "Test speech synthesis with proper intonation and pacing.",
  "voice": "alice",
  "response_format": "wav"
}

ตรวจสอบ header ตอบกลับ audio/wav
ดาวน์โหลดไฟล์ WAV และฟังเสียง

ทดสอบปลายทาง ASR

สร้าง POST request แบบ multipart/form-data
แนบไฟล์เสียงในฟิลด์ฟอร์ม
ตรวจสอบ JSON ตอบกลับว่ามี speaker ID, timestamp, transcription

ตรวจสอบสัญญา Audio API

Apidog รองรับทั้ง binary upload (ASR) และ JSON (TTS) สามารถ:

อัปโหลดไฟล์เสียง
จัดรูปแบบ JSON
ตรวจสอบ response โครงสร้าง
สลับ environment (local/cloud)

ดาวน์โหลด Apidog เพื่อทดสอบระบบ Voice AI ของคุณก่อน deploy จริง

ความปลอดภัยและการใช้งานอย่างรับผิดชอบ

มาตรการของ Microsoft:

คำเตือน AI ฝังในเสียง: “ส่วนนี้สร้างโดย AI”
ลายน้ำที่มองไม่เห็น: สำหรับตรวจสอบแหล่งที่มา
บันทึกการอนุมาน: hash log สำหรับตรวจจับ misuse
MIT License: ใช้เชิงพาณิชย์ได้ แต่ควรทดสอบก่อน production

สิ่งที่ได้รับอนุญาต

วิจัย/วิชาการ
สร้างต้นแบบ/ทดสอบในองค์กร
พอดแคสต์ (เปิดเผยว่าใช้ AI)
แอปเพื่อการเข้าถึง (TTS สำหรับผู้พิการ)

สิ่งที่ไม่ได้รับอนุญาต

แอบอ้างเสียงโดยไม่ยินยอม
Deepfake/นำเสนอเสียง AI เป็นของจริง
แปลงเสียงสดแบบเรียลไทม์ในแอป deepfake
สร้างเสียงที่ไม่ใช่ speech (เพลง, เอฟเฟกต์)

ข้อจำกัดที่ควรรู้

TTS ยังรองรับแค่ อังกฤษ/จีน ภาษาอื่นผลลัพธ์จะไม่ดี ASR รองรับ 50+ ภาษา
ASR ต้องใช้ VRAM 24GB+ (A100/H100) TTS ใช้ GPU ระดับ consumer ได้
TTS ไม่รองรับพูดทับกัน ทุกการพูดจะสลับกัน
โมเดลมี bias อาจมีเนื้อหาผิดพลาด/ลำเอียง
ซอฟต์แวร์ระดับวิจัย อาจมี bug/error ใน edge case

การติดตั้งใช้งาน VibeVoice-ASR บน Azure AI Foundry

ถ้าไม่ต้องการดูแล GPU เอง ใช้ VibeVoice-ASR บน Azure AI Foundry ได้ มี API endpoint ที่จัดการ scaling, update, maintenance ให้

ขั้นตอน:

ตรวจสอบ model catalog ของ Azure AI Foundry
กำหนดค่า endpoint/authorization ใน Apidog
ทดสอบ transcription กับไฟล์เสียงตัวอย่าง

ชุมชนและระบบนิเวศ

VibeVoice มี community ecosystem ที่แข็งแกร่ง:

ดาวน์โหลด HuggingFace 62,630+/เดือน สำหรับ 1.5B
12 โมเดล custom จากชุมชน
79+ HuggingFace Spaces
4 แบบ quantized สำหรับ VRAM ต่ำ
forks ชุมชน: vibevoice-community/VibeVoice

โปรเจกต์ชุมชนเด่น:

VibeVoice-FastAPI: REST API พร้อม Docker
VibeVoice MCP Server: เชื่อม coding AI tools
Apple Silicon support: สคริปต์ inference บน Mac M
Quantized models: GGUF ฯลฯ

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

VibeVoice ใช้งานฟรีหรือไม่?

ฟรี โมเดลทั้งหมด MIT license ใช้เชิงพาณิชย์ได้ (แต่ inference บน Azure AI Foundry มีค่าใช้จ่าย)

VibeVoice ใช้บน Apple Silicon Mac ได้ไหม?

มีสคริปต์ชุมชนสำหรับ inference บน Mac M-series ประสิทธิภาพช้ากว่า CUDA GPU แต่ใช้งานได้

VibeVoice เทียบกับ ElevenLabs ยังไง?

VibeVoice รันโลคอล ฟรี ไม่มีข้อมูลออกนอกเครื่อง ElevenLabs คุณภาพเสียงดีกว่า ตั้งค่าง่ายกว่า แต่ต้องจ่ายและข้อมูลออกคลาวด์

เหตุใด GitHub repo จึงถูกปิดชั่วคราว?

Microsoft พบ misuse (โคลนเสียง/สร้าง deepfake) จึงปิดชั่วคราว เพิ่มฟีเจอร์ความปลอดภัย แล้วเปิดใหม่ ชุมชน fork พัฒนาโค้ดต่อเนื่อง

ปรับแต่ง VibeVoice ด้วยเสียง custom ได้ไหม?

ได้ มีโมเดล custom 12 รูปแบบบน HuggingFace ต้องใช้ตัวอย่างเสียง 30–60 วินาที + GPU สำหรับเทรน

VibeVoice เอาต์พุตไฟล์เสียงแบบไหน?

WAV 24kHz โมโน แปลงเป็น MP3/OGG/FLAC ด้วย ffmpeg ได้

ใช้ VibeVoice-ASR แทน Whisper ได้ไหม?

สำหรับไฟล์ยาว/หลายผู้พูด/หลายภาษา VibeVoice-ASR ดีกว่า Whisper (Whisper เหมาะคลิปสั้น, เสียงรบกวน, ติดตั้ง edge/mobile)

VibeVoice รองรับสนทนาเสียงเรียลไทม์หรือไม่?

Realtime-0.5B รองรับ input streaming latency ~300ms เหมาะงาน quasi-realtime แต่ไม่ใช่ full-duplex voice chat

ดาวน์โหลด Apidog เพื่อทดสอบระบบ Voice AI ของคุณวันนี้