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

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

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 ครั้งแรก เตรียมสิ่งต่อไปนี้:

1. บัญชี xAI ที่ console.x.ai
2. API key จาก xAI console. แนะนำให้เก็บไว้ในตัวแปรสภาพแวดล้อม
3. Python 3.8+ หรือ Node.js 18+ (ตัวอย่างนี้มีทั้งสองภาษา)
4. 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 ครั้งเดียว):

1. POST สร้างวิดีโอ รับ request_id
2. GET ตรวจสอบสถานะ ต้อง handle "processing" ระหว่างรอ
3. 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 แบบเดิม