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

สรุปสั้นๆ

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

บทนำ

xAI สร้างวิดีโอถึง 1.2 พันล้านรายการในเดือนมกราคม 2026 เพียงเดือนเดียว ซึ่งเป็นเดือนแรกหลังจากเปิดตัว Grok text-to-video API เมื่อวันที่ 28 มกราคม 2026 โมเดลนี้ยังติดอันดับหนึ่งในตารางจัดอันดับ text-to-video ของ Artificial Analysis ในเดือนเดียวกัน ตัวเลขเหล่านี้มีความสำคัญเพราะแสดงให้เห็นว่าโครงสร้างพื้นฐานได้รับการพิสูจน์แล้วว่าสามารถรองรับปริมาณงานขนาดใหญ่ได้

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

💡

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

ปุ่ม

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

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

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

endpoint text-to-video แตกต่างจาก endpoint image-to-video ในลักษณะพื้นฐาน: คุณให้เพียงแค่คำเท่านั้น โมเดลจะสร้างฉาก, การเคลื่อนไหว, และสไตล์ภาพทั้งหมดจากคำอธิบายของคุณ ดู คู่มือ Grok image-to-video API หากคุณมีรูปภาพต้นฉบับและต้องการให้โมเดลทำให้ภาพนั้นเคลื่อนไหวแทน

การสร้างวิดีโอจากข้อความทำงานอย่างไร (อธิบายรูปแบบ async อย่างง่าย)

การเรียกใช้ API ส่วนใหญ่เป็นแบบ synchronous คุณส่งคำขอ รอสักครู่ แล้วได้รับคำตอบ การสร้างวิดีโอใช้เวลาตั้งแต่ไม่กี่วินาทีไปจนถึงหลายนาที ดังนั้น API จึงใช้รูปแบบ asynchronous (async) แทน

นี่คือขั้นตอนการทำงาน:

คุณส่งคำขอ POST พร้อม prompt ของคุณ
API จะส่ง request_id กลับมาทันที (ภายในไม่ถึงหนึ่งวินาที)
วิดีโอกำลังถูกสร้างบนเซิร์ฟเวอร์ของ xAI
คุณจะทำการตรวจสอบสถานะ (poll) ที่ GET endpoint ด้วย request_id นั้นซ้ำๆ
เมื่อสถานะเปลี่ยนจาก "processing" เป็น "done" การตอบกลับจะรวม URL ของวิดีโอไว้ด้วย

รูปแบบนี้เป็นเรื่องปกติใน AI media API ช่วยให้การเชื่อมต่อ HTTP ของคุณสั้นลงและช่วยให้คุณสามารถตรวจสอบความคืบหน้าได้ตามต้องการ ส่วนที่ยุ่งยากคือส่วนหน้า (frontend) ของคุณจำเป็นต้องจัดการสถานะระหว่างกลาง โดยการแสดงตัวบ่งชี้การโหลดจนกว่า URL วิดีโอจะมาถึง

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

ก่อนที่คุณจะเขียนโค้ดใดๆ คุณต้องมีสองสิ่งนี้:

บัญชี xAI สร้างได้ที่ console.x.ai คุณจะต้องเพิ่มข้อมูลการเรียกเก็บเงินที่นั่นก่อนที่ API key ของคุณจะสามารถเข้าถึงการสร้างวิดีโอได้

API key ในคอนโซล xAI ให้ไปที่ API Keys และสร้างคีย์ใหม่ คัดลอกเก็บไว้ในที่ปลอดภัย คุณจะต้องส่งคีย์นี้เป็น Bearer token ในทุก request header

ตั้งค่าเป็นตัวแปรสภาพแวดล้อมเพื่อหลีกเลี่ยงการ hardcode:

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

UUID นั้นคือตั๋วของคุณสำหรับเรียกดูวิดีโอเมื่อพร้อมใช้งาน

การใช้ 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}")

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

เมื่อคุณได้รับ request_id แล้ว ให้ทำการตรวจสอบสถานะที่ GET /v1/videos/{request_id} จนกว่าฟิลด์ status จะเท่ากับ "done"

ฟิลด์ status มีสามค่าที่เป็นไปได้: - "processing": กำลังสร้างอยู่ - "done": เสร็จสมบูรณ์, มี URL วิดีโอพร้อมใช้งาน - "failed": เกิดข้อผิดพลาด

นี่คือ Python polling loop แบบสมบูรณ์:

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:
    """Poll until video generation is complete."""
    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")


# Full workflow: generate then poll
def generate_video(prompt: str) -> str:
    """Generate a video and return its URL."""
    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",
  "video": {
    "url": "https://vidgen.x.ai/....mp4",
    "duration": 8,
    "respect_moderation": true
  },
  "progress": 100,
  "usage": {
    "cost_in_usd_ticks": 500000000
  }
}

การใช้ xAI Python SDK

หากคุณต้องการข้ามการตรวจสอบสถานะด้วยตนเอง xAI SDK จะจัดการให้คุณเอง เมธอด client.video.generate() จะรอจนกว่าวิดีโอจะพร้อม

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 เป็นเส้นทางที่เร็วที่สุดในการสร้างโค้ดที่ทำงานได้ ใช้แนวทางการส่งคำขอแบบ raw เมื่อคุณต้องการควบคุม retry logic, การอัปเดตความคืบหน้า หรือช่วงเวลาการตรวจสอบสถานะที่กำหนดเองได้มากขึ้น

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

prompt ของคุณคือข้อมูลนำเข้าที่สำคัญที่สุด prompt ที่ละเอียดและมีโครงสร้างจะให้ผลลัพธ์ที่ดีกว่า prompt ที่คลุมเครือมาก

คำอธิบายฉาก

อธิบายตัวแบบและฉากประกอบเข้าด้วยกัน ระบุให้ชัดเจนว่ามีอะไรปรากฏให้เห็นบ้าง "แก้วกาแฟเซรามิกสีขาววางอยู่บนโต๊ะไม้ข้างหน้าต่างที่มีรอยฝน" จะสร้างฉากที่สมจริงกว่า "แก้วกาแฟ"

การเคลื่อนไหว

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

สไตล์กล้อง

ใช้ศัพท์ทางเทคนิคเกี่ยวกับการถ่ายภาพที่คุณจะให้ผู้กำกับภาพยนตร์ เช่น "close-up," "tracking shot," "overhead drone view," "handheld," "dolly zoom" คำแนะนำเหล่านี้จะถูกแปลเป็นการถ่ายทำที่สร้างขึ้นได้อย่างน่าเชื่อถือ

แสงและบรรยากาศ

"Golden hour," "overcast," "neon-lit," และ "studio three-point lighting" ล้วนให้ภาพที่แตกต่างกัน จับคู่แสงกับบรรยากาศ: "เช้าหมอก, บรรยากาศหม่นเศร้า" จะให้คำแนะนำด้านโทนสีแก่โมเดลนอกเหนือจากอุณหภูมิสี

การอ้างอิงสไตล์

ระบุสไตล์ภาพที่คุณต้องการ เช่น "cinematic," "documentary," "anime," "stop-motion," "hyperlapse" การรวมสองสไตล์เข้าด้วยกันมักจะให้ผลลัพธ์ที่น่าสนใจ

โครงสร้าง 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.

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

endpoint สำหรับการสร้างวิดีโอรองรับพารามิเตอร์เสริมหลายรายการที่ช่วยให้คุณสามารถควบคุมขนาดเอาต์พุต, ความยาว และคุณภาพได้

ระยะเวลา

"duration": 10

ช่วง: 1 ถึง 15 วินาที ค่าเริ่มต้นคือ 6 วินาที วิดีโอที่ยาวขึ้นจะมีค่าใช้จ่ายเพิ่มขึ้น คลิปความยาว 10 วินาทีที่ 480p มีค่าใช้จ่าย $0.50

ความละเอียด

"resolution": "720p"

มีสองตัวเลือก: "480p" (ค่าเริ่มต้น) และ "720p" ใช้ 480p สำหรับการสร้างต้นแบบและการทดสอบ ใช้ 720p สำหรับผลลัพธ์การผลิตที่คุณภาพมีความสำคัญ

อัตราส่วนภาพ

"aspect_ratio": "9:16"

อัตราส่วนที่ใช้ได้:

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

ตัวอย่างแบบเต็มพร้อมพารามิเตอร์ทั้งหมด

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 ยอมรับอาร์เรย์ของ URL รูปภาพสูงสุด 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"}
  ]
}

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

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

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

xAI มี endpoint เพิ่มเติมสองรายการสำหรับทำงานกับวิดีโอที่คุณสร้างไว้แล้ว

ขยายวิดีโอ

POST /v1/videos/extensions เพิ่มฟุตเทจ (footage) เข้าไปในวิดีโอที่สร้างขึ้นแล้ว คุณส่ง request_id ของวิดีโอต้นฉบับและ prompt ใหม่สำหรับการขยาย ซึ่งมีประโยชน์สำหรับการสร้างซีเควนซ์ที่ยาวขึ้นโดยไม่ติดขีดจำกัด 15 วินาทีในการเรียกใช้ครั้งเดียว

แก้ไขวิดีโอ

POST /v1/videos/edits แก้ไขวิดีโอที่มีอยู่ตามคำสั่งข้อความ คุณสามารถเปลี่ยนสไตล์, ปรับเปลี่ยนฉาก, หรือใช้เอฟเฟกต์กับคลิปที่คุณสร้างไว้แล้วได้

ทั้งสอง endpoint ทำตามรูปแบบ async เดียวกันกับ main generation endpoint โดยจะส่ง request_id กลับมา และคุณทำการตรวจสอบสถานะที่ GET /v1/videos/{request_id} เพื่อดูผลลัพธ์

การอ่านค่าใช้จ่ายจากการตอบกลับ API

การตอบกลับจากการตรวจสอบสถานะที่สมบูรณ์จะรวมออบเจกต์ usage ไว้ด้วย:

"usage": {
  "cost_in_usd_ticks": 500000000
}

หน่วยเป็น USD ticks หารด้วย 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

ค่า 500000000 ticks เท่ากับ $0.50 นั่นคือคลิปความยาว 10 วินาทีที่ความละเอียด 480p

ติดตามค่าใช้จ่ายของคุณโดยการบันทึก cost_in_usd_ticks จากทุกการตอบกลับที่เสร็จสมบูรณ์ ซึ่งช่วยให้คุณสามารถสร้างแดชบอร์ดการใช้งานโดยไม่ต้องเรียกใช้ xAI billing API แยกต่างหาก

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

รูปแบบการตรวจสอบสถานะแบบ async สร้างความท้าทายในการทดสอบโดยเฉพาะ โค้ดส่วนหน้าของคุณจำเป็นต้องจัดการสามสถานะ: กำลังโหลด (ขณะตรวจสอบสถานะ), สำเร็จ (ได้รับ URL วิดีโอ), และข้อผิดพลาด คุณไม่สามารถทดสอบทั้งสามสถานะโดยการเรียกใช้ API จริงได้ เนื่องจากแต่ละการเรียกใช้ใช้เวลาและมีค่าใช้จ่าย นี่คือจุดที่ฟีเจอร์ Smart Mock ของ Apidog เข้ามาแก้ปัญหาโดยตรง

กรณีใช้งานที่ 1: Smart Mock สำหรับการพัฒนาส่วนหน้า

ด้วย Smart Mock ของ Apidog คุณสามารถกำหนด schema สำหรับทั้งสอง endpoint และ Apidog จะส่งการตอบกลับปลอมที่สมจริงทันที

จำลอง generation endpoint:

ใน Apidog ให้สร้าง 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} ใน Apidog กำหนด response schema แบบเต็ม รวมถึง status, video.url, video.duration, progress และ usage.cost_in_usd_ticks ตั้งค่า Custom Mock response ที่ส่งกลับ "status": "done" พร้อมกับ URL MP4 ตัวยึด (placeholder)

การตอบกลับจากการตรวจสอบสถานะที่จำลองของคุณ:

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

ตอนนี้นักพัฒนาส่วนหน้าสามารถสร้างและทดสอบ UI โปรแกรมเล่นวิดีโอทั้งหมดกับเซิร์ฟเวอร์จำลองนี้ได้แล้ว พวกเขาสามารถเห็นสถานะกำลังโหลด, สถานะเสร็จสมบูรณ์ และสามารถเรียกใช้สถานะข้อผิดพลาดได้โดยการปรับเปลี่ยน mock ให้ส่งกลับ "status": "failed" ไม่มีเครดิต API จริงถูกใช้จ่ายในระหว่างการพัฒนา

กรณีใช้งานที่ 2: สถานการณ์ทดสอบสำหรับ polling loop

เมื่อการรวมระบบของคุณสร้างเสร็จแล้ว ให้ใช้ Test Scenarios ของ Apidog เพื่อตรวจสอบความถูกต้องของขั้นตอนการสร้างแล้วตรวจสอบสถานะทั้งหมดโดยอัตโนมัติ

ขั้นตอนที่ 1: เพิ่มคำขอสร้างวิดีโอ เพิ่ม POST /v1/videos/generations เป็นขั้นตอนแรกในสถานการณ์ทดสอบของคุณ ใน post-processor ให้เพิ่ม Extract Variable เพื่อดึง request_id จาก response body โดยใช้ JSONPath expression $.request_id จัดเก็บไว้ในตัวแปรชื่อ videoRequestId

ขั้นตอนที่ 2: เพิ่ม polling loop เพิ่ม GET /v1/videos/{{videoRequestId}} เป็นขั้นตอนที่สอง ห่อด้วย For loop โดยมีเงื่อนไขการหยุด: response.body.status == "done" เพิ่ม Wait processor 5 วินาทีระหว่างการวนซ้ำเพื่อหลีกเลี่ยงการโจมตี rate limit

ขั้นตอนที่ 3: ยืนยันผลลัพธ์ หลังจากลูปสิ้นสุด ให้เพิ่ม Assertion processor ไปยังคำขอ GET สุดท้าย ยืนยันว่า $.video.url ไม่ว่างเปล่า สิ่งนี้เป็นการยืนยันว่าวงจรทั้งหมดเสร็จสมบูรณ์แล้ว

สถานการณ์ทดสอบนี้ให้การครอบคลุมแบบอัตโนมัติและทำซ้ำได้ของ async flow รันใน CI เพื่อตรวจจับข้อบกพร่องใดๆ เมื่อ polling logic ของคุณเปลี่ยนแปลง

Text-to-video vs image-to-video: ควรใช้อันไหนเมื่อใด

ทั้งสองโหมดใช้โมเดล grok-imagine-video เดียวกัน แต่มีวัตถุประสงค์ที่แตกต่างกัน

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

เลือกใช้ image-to-video เมื่อ:- คุณมีรูปภาพสินค้า, ภาพประกอบ หรือ assets ของแบรนด์ที่ต้องการทำให้เคลื่อนไหว - คุณต้องการคงรายละเอียดภาพเฉพาะจากรูปภาพที่มีอยู่ - คุณกำลังสร้างแอนิเมชั่นที่สอดคล้องกันจากชุดรูปภาพที่เกี่ยวข้องกัน - คุณต้องการทำให้งานศิลปะหรือภาพถ่ายของคุณเคลื่อนไหว

ความแตกต่างที่สำคัญ: text-to-video สร้างฉากขึ้นใหม่ทั้งหมด ส่วน image-to-video ทำให้รูปภาพที่มีอยู่เคลื่อนไหว สำหรับคำแนะนำฉบับเต็มเกี่ยวกับวิธีการ image-to-video โปรดดู คู่มือ Grok image-to-video API

สำหรับทีมที่สร้างผลิตภัณฑ์ที่รองรับทั้งสองโหมด คุณสามารถตรวจจับประเภทของอินพุตในขณะรันไทม์ได้ หากผู้ใช้อัปโหลดรูปภาพ ให้ส่งไปยัง POST /v1/images/generations (image-to-video) หากพวกเขาพิมพ์เพียง prompt ให้ส่งไปยัง POST /v1/videos/generations

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

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

429 Too Many Requests คุณเกินขีดจำกัดการเรียกใช้ API (rate limit) API อนุญาตให้เรียกใช้ได้ 60 คำขอต่อนาที และ 1 คำขอต่อวินาที เพิ่มการหน่วงเวลาระหว่างคำขอ หากคุณกำลังตรวจสอบสถานะ ให้เว้นช่วงการเรียกใช้ของคุณอย่างน้อย 5 วินาที

status: "failed" ในการตอบกลับจากการตรวจสอบสถานะ การสร้างวิดีโอไม่สำเร็จ โดยปกติหมายความว่า prompt ถูกปฏิเสธโดยระบบการกลั่นกรองเนื้อหา (content moderation) ฟิลด์ respect_moderation ในการตอบกลับจากการตรวจสอบสถานะจะระบุว่ามีการใช้การกลั่นกรองเนื้อหา ปรับแก้ prompt ของคุณให้ชัดเจนขึ้น หรือลบภาษาที่อาจอ่อนไหวออก

URL วิดีโอส่งคืน 404 URL วิดีโอที่สร้างขึ้นจะหมดอายุหลังจากระยะเวลาหนึ่ง ดาวน์โหลดวิดีโอไปยังที่เก็บข้อมูลของคุณทันทีหลังจากได้รับ URL อย่าเก็บ URL ไว้และคาดหวังว่ามันจะยังคงใช้งานได้ในอีกหลายวันข้างหน้า

วิดีโอว่างเปล่าหรือค้าง prompt ที่คลุมเครือหรือ prompt ที่ไม่มีคำแนะนำการเคลื่อนไหวบางครั้งสร้างวิดีโอที่มีการเคลื่อนไหวน้อยมาก เพิ่มภาษาที่บ่งบอกการเคลื่อนไหวที่ชัดเจนลงใน prompt ของคุณ: อธิบายว่าอะไรเคลื่อนไหว ไปในทิศทางใด และด้วยความเร็วเท่าใด

เวลาในการตรวจสอบสถานะช้า วิดีโอ 720p ใช้เวลาในการสร้างนานกว่า 480p ระยะเวลาที่ยาวขึ้นก็ใช้เวลานานขึ้นเช่นกัน สำหรับการพัฒนาและการสร้างต้นแบบ ให้ใช้ "resolution": "480p" และระยะเวลาสั้นๆ เพื่อเร่งรอบการทำงาน

บทสรุป

Grok text-to-video API มอบเส้นทางที่ตรงไปตรงมาจากการสร้างวิดีโอจากข้อความ คุณส่ง prompt, ได้รับ request_id, ตรวจสอบสถานะจนกว่าจะเสร็จสมบูรณ์, และเรียกไฟล์ MP4 ของคุณ รูปแบบ asynchronous เป็นแนวคิดสำคัญที่ต้องทำความเข้าใจ เมื่อคุณทำให้ polling loop ทำงานได้แล้ว พารามิเตอร์ที่เหลือ (ระยะเวลา, ความละเอียด, อัตราส่วนภาพ, รูปภาพอ้างอิง) ก็ง่ายต่อการปรับแต่ง

สำหรับการสร้างเวอร์ชันใช้งานจริง ให้เพิ่มการติดตามค่าใช้จ่ายโดยการอ่าน cost_in_usd_ticks จากทุกการตอบกลับที่เสร็จสมบูรณ์ จำลอง endpoint ทั้งสองใน Apidog ระหว่างการพัฒนา เพื่อให้ทีมส่วนหน้าของคุณไม่ถูกบล็อกรอการสร้างจริง ใช้ Test Scenarios เพื่อให้ polling logic ของคุณน่าเชื่อถือเมื่อการรวมระบบของคุณพัฒนาขึ้น

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

ปุ่ม

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

ฉันใช้ชื่อโมเดลอะไรในการสร้างวิดีโอจากข้อความ? ใช้ grok-imagine-video นี่คือฟิลด์ model ที่จำเป็นในคำขอ POST ของคุณไปยัง /v1/videos/generations

การสร้างวิดีโอใช้เวลานานเท่าไหร่? แตกต่างกันไปขึ้นอยู่กับระยะเวลาและความละเอียด คลิปสั้นๆ ที่ 480p อาจเสร็จภายในไม่ถึง 30 วินาที คลิปที่ยาวกว่าที่ 720p อาจใช้เวลาหลายนาที ตรวจสอบสถานะทุก 5-10 วินาที แทนที่จะเรียกใช้ endpoint อย่างต่อเนื่อง

ฉันสามารถสร้างวิดีโอที่ยาวกว่า 15 วินาทีได้หรือไม่? ไม่ได้ในการร้องขอครั้งเดียว duration สูงสุดคือ 15 วินาที หากต้องการสร้างวิดีโอที่ยาวขึ้น ให้สร้างคลิปหนึ่ง แล้วใช้ POST /v1/videos/extensions เพื่อเพิ่มฟุตเทจเพิ่มเติม

ฉันจะดาวน์โหลดวิดีโอที่สร้างขึ้นได้อย่างไร? ใช้ URL จาก result.video.url ในการตอบกลับจากการตรวจสอบสถานะที่สมบูรณ์ ดาวน์โหลดไฟล์ MP4 ไปยังที่เก็บข้อมูลของคุณทันที URL นี้เป็นแบบชั่วคราวและจะหมดอายุ

จะเกิดอะไรขึ้นหาก prompt ของฉันละเมิดการกลั่นกรองเนื้อหา? งานจะเสร็จสมบูรณ์ แต่ status จะเป็น "failed" ฟิลด์ respect_moderation ในการตอบกลับจากการตรวจสอบสถานะจะระบุว่ามีการใช้การกลั่นกรองเนื้อหา ปรับแก้ prompt ของคุณแล้วลองใหม่อีกครั้ง

มีบริการฟรีสำหรับ video API หรือไม่? xAI คิดค่าใช้จ่ายต่อวินาทีของผลลัพธ์ที่สร้างขึ้น ไม่มีบริการฟรีสำหรับ video generation โดยเฉพาะ ตรวจสอบที่ console.x.ai สำหรับข้อเสนอเครดิตปัจจุบันสำหรับบัญชีใหม่

reference_images แตกต่างจากการเริ่มต้นด้วยรูปภาพต้นฉบับอย่างไร? รูปภาพอ้างอิงจะช่วยกำหนดสไตล์ภาพของการสร้างวิดีโอจากข้อความ โดยมีอิทธิพลต่อรูปลักษณ์โดยไม่กลายเป็นตัวแบบ รูปภาพต้นฉบับสำหรับ image-to-video จะกลายเป็นเฟรมแรกของวิดีโอจริงๆ

วิธีที่ดีที่สุดในการทดสอบ polling loop โดยไม่เสียเครดิตคืออะไร? ใช้ Smart Mock ของ Apidog เพื่อจำลองทั้ง generation และ poll endpoints กำหนด schemas, ตั้งค่า mock responses สำหรับสถานะ "processing" และ "done" แล้วโค้ด polling ของคุณจะทำงานได้โดยไม่ต้องแตะ API จริง