วิธีใช้ 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

บทนำ

เมื่อวันที่ 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. เก็บไว้ในตัวแปรสภาพแวดล้อม ไม่ใช่เขียนโค้ดแบบ hardcoded
Python 3.8+ หรือ Node.js 18+ (ตัวอย่างในคู่มือนี้ใช้ทั้งสองภาษา)
URL ของรูปภาพที่เข้าถึงได้จากสาธารณะ หรือรูปภาพที่เข้ารหัส base64 เป็น data URI

กำหนดคีย์ของคุณเป็นตัวแปรสภาพแวดล้อม:

export XAI_API_KEY="your_key_here"

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

pip install xai-sdk

สำหรับการเรียก HTTP โดยตรง ไม่จำเป็นต้องใช้แพ็กเกจเพิ่มเติม นอกเหนือจาก 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"
}

วิดีโอจะยังไม่พร้อมใช้งาน การสร้างจะเกิดขึ้นแบบอะซิงโครนัสบนโครงสร้างพื้นฐานของ xAI คุณต้องตรวจสอบสถานะเพื่อรับผลลัพธ์

การใช้งาน Python (คำขอโดยตรง)

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

หากรูปภาพของคุณเป็นไฟล์ในเครื่องหรือไม่ได้เผยแพร่สู่สาธารณะ ให้เข้ารหัสเป็น data URI:

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 ในขณะที่วิดีโอกำลังถูกเรนเดอร์บนเซิร์ฟเวอร์ของ xAI คุณต้องตรวจสอบสถานะที่ 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")

ควรกำหนดช่วงเวลาการตรวจสอบสถานะ (polling interval) ไว้ที่ 5 วินาทีหรือนานกว่านั้น API มีข้อจำกัดการเรียกใช้งานที่ 60 คำขอต่อนาที (1 คำขอต่อวินาที) การตรวจสอบสถานะถี่เกินไปพร้อมกันหลายงานอาจทำให้โควต้าหมดลงอย่างรวดเร็ว

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

ไลบรารี xai-sdk ช่วยจัดการรูปแบบอะซิงโครนัสให้คุณ client.video.generate() จะส่งงานและรอจนกว่าวิดีโอจะพร้อม โดยจัดการการตรวจสอบสถานะทั้งหมดภายใน:

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

SDK จะจัดการการวนลูปตรวจสอบสถานะ, การตรวจสอบสถานะ, และการส่งต่อข้อผิดพลาด ใช้วิธีนี้เมื่อคุณต้องการโค้ดแอปพลิเคชันที่สะอาดตา โดยไม่ต้องจัดการการตรวจสอบสถานะ HTTP ด้วยตัวเอง

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

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

Grok video API ช่วยให้คุณควบคุมรูปแบบเอาต์พุตได้โดยตรง

ระยะเวลา (Duration)

พารามิเตอร์ duration รับค่าจำนวนเต็มตั้งแต่ 1 ถึง 15 วินาที ค่าเริ่มต้นคือ 6

"duration": 10

วิดีโอที่ยาวขึ้นจะมีค่าใช้จ่ายสูงขึ้น คลิป 10 วินาทีมีค่าใช้จ่ายประมาณ 10 เท่าของคลิป 1 วินาทีที่มีความละเอียดเท่ากัน

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

มีสองตัวเลือกให้เลือก:

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

"resolution": "720p"

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

พารามิเตอร์ aspect_ratio ควบคุมขนาดเฟรมของวิดีโอที่สร้างขึ้น:

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

เมื่อคุณระบุพารามิเตอร์ image อัตราส่วนภาพเริ่มต้นจะตรงกับขนาดของรูปภาพต้นฉบับ หากต้องการเปลี่ยนแปลงหรือคร็อป ให้กำหนดค่าอย่างชัดเจน

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

พารามิเตอร์ reference_images แตกต่างจากพารามิเตอร์ image การทำความเข้าใจความแตกต่างเป็นสิ่งสำคัญ

image: รูปถ่ายต้นฉบับที่จะกลายเป็น เฟรมแรก ของวิดีโอ โมเดลจะสร้างภาพเคลื่อนไหวจากจุดเริ่มต้นนี้

reference_images: อาร์เรย์ของรูปภาพสูงสุด 7 รูป ที่ใช้เป็นแนวทางในด้าน สไตล์ เนื้อหา หรือบริบททางภาพ ของวิดีโอที่สร้างขึ้น รูปภาพเหล่านี้ไม่ใช่เฟรมในวิดีโอเอาต์พุต แต่มีอิทธิพลต่อวิธีที่โมเดลเรนเดอร์การเคลื่อนไหวและรูปลักษณ์

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

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

ในตัวอย่างนี้ product-shot.jpg คือเฟรมแรก รูปภาพอ้างอิงจะเป็นแนวทางในการจัดแสงและสไตล์

คุณสามารถระบุรูปภาพอ้างอิงได้โดยไม่ต้องมีรูปภาพเฟรมแรกเลย ในกรณีนั้น โมเดลจะสร้างวิดีโอจากข้อความ (text-to-video) โดยดึงแนวทางสไตล์จากรูปภาพอ้างอิง

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

API รองรับการดำเนินการเพิ่มเติมอีกสองอย่างนอกเหนือจากการสร้างวิดีโอเริ่มต้น

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

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
  }'

การตอบกลับเป็นไปตามรูปแบบอะซิงโครนัสเช่นเดียวกัน: ตรวจสอบสถานะที่ 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"
  }'

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

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

xAI video API คิดค่าบริการสำหรับสองส่วนประกอบ: การประมวลผลรูปภาพอินพุต และระยะเวลาของวิดีโอเอาต์พุต

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

ตัวอย่าง: วิดีโอ 10 วินาทีที่ความละเอียด 720p

รูปภาพอินพุต: $0.002
วิดีโอเอาต์พุต: 10 วินาที × $0.07 = $0.70
รวมทั้งหมด: $0.702

ตัวอย่าง: วิดีโอ 6 วินาทีที่ความละเอียด 480p (การตั้งค่าเริ่มต้น)

รูปภาพอินพุต: $0.002
วิดีโอเอาต์พุต: 6 วินาที × $0.05 = $0.30
รวมทั้งหมด: $0.302

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

Text-to-video (ไม่มีพารามิเตอร์ image) จะไม่มีค่าใช้จ่ายอินพุต $0.002 แต่จะมีราคาต่อวินาทีเหมือนกัน

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

รูปแบบอะซิงโครนัสสร้างความท้าทายในการทดสอบที่การทดสอบคำขอแบบครั้งเดียวไม่สามารถครอบคลุมได้ คุณต้องยืนยันว่า:

คำขอสร้างวิดีโอส่งคืน request_id
คำขอตรวจสอบสถานะจัดการสถานะ "processing" ได้อย่างถูกต้องในระหว่างรอ
การตอบกลับสุดท้ายมี status == "done" และ URL วิดีโอที่ไม่ว่างเปล่า

Test Scenarios ของ Apidog จะเชื่อมโยงขั้นตอนเหล่านี้เข้าด้วยกันเป็นขั้นตอนอัตโนมัติเดียว นี่คือวิธีสร้างมัน:

ขั้นตอนที่ 1: สร้าง Test Scenario ใหม่

ใน Apidog ให้เปิดโมดูล Tests และคลิกปุ่ม + เพื่อสร้าง scenario ใหม่ ตั้งชื่อว่า "Grok image-to-video async flow"

ขั้นตอนที่ 2: เพิ่มคำขอสร้างวิดีโอ

เพิ่มขั้นตอนคำขอ POST แบบกำหนดเอง:

URL: https://api.x.ai/v1/videos/generations
เมธอด: POST
ส่วนหัว: Authorization: Bearer {{xai_api_key}}
เนื้อหา (JSON):

{
  "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 ให้เพิ่มโปรเซสเซอร์ Extract Variable กำหนดค่า:

ชื่อตัวแปร: video_request_id
แหล่งที่มา: เนื้อหาการตอบกลับ
วิธีการดึงข้อมูล: JSONPath
นิพจน์ JSONPath: $.request_id

Apidog จะจัดเก็บค่าที่ดึงมาได้ใน {{video_request_id}} เพื่อใช้ในขั้นตอนถัดไป

ขั้นตอนที่ 4: สร้างการวนลูป Polling

เพิ่มโปรเซสเซอร์ For loop ภายในลูป ให้เพิ่มคำขอตรวจสอบสถานะ:

URL: https://api.x.ai/v1/videos/{{video_request_id}}
เมธอด: GET
ส่วนหัว: Authorization: Bearer {{xai_api_key}}

เพิ่มโปรเซสเซอร์ Extract Variable ภายในลูปเพื่อดึงสถานะปัจจุบัน:

ชื่อตัวแปร: video_status
JSONPath: $.status

เพิ่มโปรเซสเซอร์ Wait (5000ms) หลังจากการดึงสถานะ เพื่อหลีกเลี่ยงการติดขีดจำกัดอัตรา (rate limit)

ตั้งค่าเงื่อนไข Break If ของลูป: {{video_status}} == "done"

ขั้นตอนที่ 5: ยืนยัน URL ของวิดีโอ

หลังจาก For loop ให้เพิ่มขั้นตอน GET สุดท้ายไปยัง endpoint การตรวจสอบสถานะเดิม เพิ่มโปรเซสเซอร์ Assertion:

ฟิลด์: $.video.url
เงื่อนไข: ไม่เป็นค่าว่าง

การยืนยันนี้ช่วยยืนยันว่ามี URL ของวิดีโออยู่จริงก่อนที่การทดสอบของคุณจะผ่าน

สำหรับข้อมูลเชิงลึกเพิ่มเติมเกี่ยวกับวิธีทดสอบ Async API ด้วย Apidog รวมถึงรูปแบบการตรวจสอบสถานะที่ซับซ้อนขึ้นและการรวม CI/CD โปรดดูคู่มือเฉพาะนั้น

การเรียกใช้ Scenario

คลิก Run ในหน้า Test scenario Apidog จะดำเนินการ POST, ดึงค่า request_id, วนลูปตรวจสอบสถานะจนกว่า status == "done", จากนั้นจึงประเมินการยืนยันของคุณ รายงานการทดสอบจะแสดงสถานะและระยะเวลาของแต่ละขั้นตอน

คุณสามารถเชื่อมโยง scenario นี้เข้ากับ CI/CD pipeline ของคุณด้วย Apidog CLI:

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

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

401 Unauthorized (ไม่ได้รับอนุญาต)

API key ของคุณหายไปหรือไม่ถูกต้อง ตรวจสอบรูปแบบส่วนหัว Authorization: Bearer YOUR_XAI_API_KEY ยืนยันว่าคีย์เปิดใช้งานอยู่แล้วใน xAI console

422 Unprocessable Entity (ไม่สามารถประมวลผลเอนทิตีได้)

request body ไม่ถูกต้อง สาเหตุทั่วไป: ฟิลด์ model หายไป, prompt ว่างเปล่า, หรือ image.url ไม่สามารถเข้าถึงได้ ทดสอบ URL รูปภาพในเบราว์เซอร์ก่อนใช้งาน

URL รูปภาพไม่สามารถเข้าถึงได้

เซิร์ฟเวอร์ของ xAI ต้องสามารถดึง URL รูปภาพได้ในขณะสร้างวิดีโอ URL ส่วนตัว, ที่อยู่ localhost, หรือ URL ที่มีการยืนยันตัวตนจะล้มเหลว ให้ใช้ Public CDN หรือ base64 data URI แทน

สถานะค้างอยู่ที่ "processing" อย่างไม่มีกำหนด

การสร้างวิดีโออาจใช้เวลาตั้งแต่ 30 วินาทีถึงหลายนาที ขึ้นอยู่กับความละเอียดและระยะเวลา หากสถานะยังคงเป็น "processing" นานกว่า 10 นาที งานอาจหยุดชะงัก ส่งคำขอใหม่ ปัจจุบัน xAI API ไม่ได้เปิดเผยสัญญาณหมดเวลาแยกต่างหากจากสถานะ "failed"

ข้อผิดพลาดจากการจำกัดอัตราการใช้งาน (Rate limit errors - 429)

API อนุญาตให้ส่งคำขอได้ 60 ครั้งต่อนาที และ 1 ครั้งต่อวินาที หากคุณกำลังตรวจสอบสถานะหลายงานพร้อมกัน ให้จัดลำดับคำขอของคุณ ควรเพิ่ม time.sleep(1) ขั้นต่ำระหว่างการเรียกตรวจสอบสถานะ

การอัปโหลด Base64 ถูกปฏิเสธ

ตรวจสอบให้แน่ใจว่า data URI ของคุณมีคำนำหน้า MIME type ที่ถูกต้อง ใช้ data:image/jpeg;base64, สำหรับไฟล์ JPEG และ data:image/png;base64, สำหรับไฟล์ PNG

อัตราส่วนภาพไม่ตรงกัน

เมื่อคุณตั้งค่า aspect_ratio อย่างชัดเจนที่แตกต่างอย่างมีนัยสำคัญจากสัดส่วนของรูปภาพต้นฉบับ โมเดลอาจคร็อปหรือสร้างแถบดำ (letterbox) จับคู่อัตราส่วนภาพให้ตรงกับรูปภาพต้นฉบับของคุณเพื่อผลลัพธ์ที่ดีที่สุด

สรุป

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

รูปแบบการตรวจสอบสถานะแบบอะซิงโครนัสคือจุดที่การเชื่อมต่อส่วนใหญ่เกิดข้อผิดพลาด การทดสอบที่เหมาะสมใน Test Scenarios ของ Apidog ครอบคลุมขั้นตอน Extract Variable, การวนลูปตรวจสอบสถานะพร้อมเงื่อนไขหยุด, และการยืนยัน URL สุดท้าย การรวมกันนี้จะช่วยตรวจจับปัญหาได้ก่อนที่จะส่งขึ้นสู่เวอร์ชันใช้งานจริง

ปุ่ม

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

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

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

ชื่อโมเดลคือ grok-imagine-video. ส่งค่านี้เป็นฟิลด์ model ใน request body ของคำขอ POST ของคุณ

พารามิเตอร์ image และ reference_images แตกต่างกันอย่างไร?

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

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

เวลาในการสร้างแตกต่างกันไปตามระยะเวลาและความละเอียด วิดีโอ 6 วินาทีที่ความละเอียด 480p โดยทั่วไปจะใช้เวลา 1 ถึง 3 นาที วิดีโอ 15 วินาทีที่ความละเอียด 720p อาจใช้เวลา 4 ถึง 8 นาที ตรวจสอบสถานะทุก 5 วินาทีเพื่อหลีกเลี่ยงการใช้โควต้าอัตราการใช้งานจนหมด

ฉันสามารถใช้ไฟล์ในเครื่องเป็นรูปภาพต้นฉบับได้หรือไม่?

ได้ เข้ารหัสไฟล์ในเครื่องของคุณเป็น base64 data URI: data:image/jpeg;base64,{encoded_bytes} ส่งสตริงนั้นเป็นค่า url ภายในออบเจกต์ image

จะเกิดอะไรขึ้นหากฉันไม่ระบุ aspect_ratio?

เมื่อคุณระบุพารามิเตอร์ image อัตราส่วนภาพจะถูกตั้งค่าเริ่มต้นให้ตรงกับสัดส่วนของรูปภาพต้นฉบับ เมื่อสร้างวิดีโอจากข้อความ (text-to-video) โดยไม่มีรูปภาพ ค่าเริ่มต้นคือ 16:9

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

รูปภาพอินพุตมีค่าใช้จ่าย $0.002 วิดีโอเอาต์พุตมีค่าใช้จ่าย 10 × $0.07 = $0.70 รวมทั้งหมด: ประมาณ $0.702 ต่อวิดีโอ

ข้อจำกัดอัตราการใช้งาน (Rate limits) คืออะไร?

API อนุญาตให้ส่งคำขอได้ 60 ครั้งต่อนาที และ 1 ครั้งต่อวินาที ซึ่งครอบคลุมทั้งคำขอ POST สำหรับการสร้างและคำขอ GET สำหรับการตรวจสอบสถานะรวมกัน

ฉันสามารถต่อเติมวิดีโอให้ยาวกว่า 15 วินาทีได้หรือไม่?

ได้ ด้วยการใช้ endpoint POST /v1/videos/extensions คุณสามารถสร้างคลิปเริ่มต้นได้สูงสุด 15 วินาที จากนั้นจึงต่อเติมด้วยการสร้างเพิ่มเติม การต่อเติมแต่ละครั้งยังคงใช้รูปแบบการตรวจสอบสถานะแบบอะซิงโครนัสเช่นเดียวกัน