HappyHorse 1.1 แตกต่างจาก Seedance 2.5 อย่างไร?

HappyHorse 1.1 เน้นการสร้างวิดีโอแบบสั้นคุณภาพสูงและการซิงก์ภาพและเสียง ในขณะที่ Seedance 2.5 ให้ความสำคัญกับวิดีโอที่ยาวกว่าและการควบคุมอ้างอิงแบบหลายโมดาลิตีขนาดใหญ่.

HappyHorse 1.1 รองรับความละเอียดวิดีโออะไรบ้าง?

HappyHorse 1.1 รองรับโหมดเอาต์พุตทั้ง 720p และ 1080p.

HappyHorse 1.1 สร้างวิดีโอจากพรอมต์ข้อความได้หรือไม่?

ใช่. HappyHorse 1.1 รองรับการสร้างวิดีโอจากข้อความ และสามารถสร้างวิดีโอความละเอียด 720p หรือ 1080p ได้จากพรอมต์ข้อความที่มีรายละเอียด.

HappyHorse 1.1 รองรับการสร้างวิดีโอจากภาพหรือไม่?

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

HappyHorse 1.1 สามารถสร้างวิดีโอที่ซิงก์เสียงให้ตรงกันได้หรือไม่?

ตระกูล HappyHorse ถูกสร้างขึ้นบนสถาปัตยกรรมภาพ-เสียงแบบรวมเป็นหนึ่งเดียวที่สร้างองค์ประกอบภาพและเสียงร่วมกัน ช่วยปรับปรุงการซิงก์และคุณภาพการลิปซิงค์.

HappyHorse 1.1 เหมาะสำหรับการสร้างคอนเทนต์เชิงพาณิชย์หรือไม่?

ใช่. ได้รับการออกแบบสำหรับงานโฆษณา การตลาด การผลิตคอนเทนต์โซเชียลมีเดีย การเล่าเรื่อง และกรณีการใช้งานการสร้างวิดีโอระดับมืออาชีพอื่น ๆ.

HappyHorse 1.1 รองรับการสร้างวิดีโอแบบอ้างอิงหรือไม่?

ใช่. โมเดลมีเวิร์กโฟลว์แบบอ้างอิงสู่วิดีโอที่ช่วยให้ผู้สร้างใช้แอสเซ็ตภาพที่มีอยู่ในการกำกับการสร้าง.

HappyHorse 1.1 มีการปรับปรุงอะไรบ้างเมื่อเทียบกับ HappyHorse 1.0?

HappyHorse 1.1 ปรับปรุงความเข้าใจพรอมต์ ความลื่นไหลของการเคลื่อนไหว ความสม่ำเสมอเชิงเวลา และคุณภาพวิดีโอโดยรวม ในเวิร์กโฟลว์ T2V, I2V และ R2V.

Aliyun

พร้อมใช้งาน

happyhorse-1.1

Happy Horse 1.1 API

HappyHorse 1.1 คือโมเดลสร้างวิดีโอแบบมัลติโหมด ออกแบบมาสำหรับการสร้างคอนเทนต์ระดับมืออาชีพ การโฆษณา หนังสั้น การผลิตสื่อบนโซเชียลมีเดีย และการเล่าเรื่อง ความสามารถของรุ่นนี้ต่อยอดมาจาก HappyHorse 1.0—ซึ่งได้รับความสนใจอย่างมากหลังจากติดอันดับสูงในการประเมินการสร้างวิดีโอโดยอิสระ—ด้วยความสอดคล้องของฉากที่ดีขึ้นและความเที่ยงตรงด้านภาพที่สูงขึ้น.

ราคาเริ่มต้น

$0.112 / วินาที

คิดค่าบริการตามการใช้งาน

สถานะ API

พร้อมใช้งาน

เอนด์พอยต์สำหรับโปรดักชัน

เวลาตอบสนอง

รองรับการทำงานแบบ async

เวลาตอบสนอง API ที่วัดได้จริง

วันที่เผยแพร่

Jun 28, 2026

Aliyun

พื้นที่ทดลอง

ลองใช้ Happy Horse 1.1 ด้วยคำขอจริง ตรวจสอบพารามิเตอร์ และตรวจสอบผลลัพธ์ก่อนเชื่อมต่อ API

ราคา

ใช้การประเมินค่าใช้จ่ายอย่างรวดเร็วด้านบนสำหรับการรันครั้งเดียว จากนั้นดูการเปรียบเทียบราคาฉบับเต็มระหว่าง CometAPI และราคาทางการ

ทดสอบ 5 วินาที

$0.5600

ค่าใช้จ่ายโดยประมาณในการใช้งาน CometAPI

ทดสอบ 10 วินาที

$1.12

ค่าใช้จ่ายโดยประมาณในการใช้งาน CometAPI

ทดสอบ 15 วินาที

$1.68

ค่าใช้จ่ายโดยประมาณในการใช้งาน CometAPI

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

Happyhorse Video Generation Pricing

Pricing (Per Second)

Model	720p	1080p
`happyhorse-1.1`	$0.112	$0.144

💡 Billed per second. Total cost = price per second × video duration (seconds).

สรุปโมเดล

อัตลักษณ์โมเดลที่คงที่สำหรับการค้นหาและการประเมินผล ควบคู่กับข้อมูลแคตตาล็อกแบบเรียลไทม์ที่เปลี่ยนแปลงได้โดยไม่ต้องเขียนโครงสร้าง SEO หลักของหน้าใหม่

อัตลักษณ์ที่คงที่

Happy Horse 1.1 คืออะไร

อัตลักษณ์หลักของโมเดลยังคงเดิม แม้ว่าราคาและข้อจำกัดจะเปลี่ยนแปลง

ข้อมูลโมเดลแบบเรียลไทม์

ภาพรวมแคตตาล็อกปัจจุบัน

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

พร้อมใช้งาน

ราคาเริ่มต้น

$0.112 / วินาที

บริบท

ดูความสามารถ

วันที่ของแคตตาล็อก

Jun 28, 2026

ภาพรวม

ภาพรวมการใช้งานจริงของ Happy Horse 1.1 รวมถึงพฤติกรรมสำคัญและข้อควรพิจารณาในการเชื่อมต่อ

ข้อมูลจำเพาะทางเทคนิคของ HappyHorse 1.1

รายการ	HappyHorse 1.1
ผู้ให้บริการ	Alibaba
ประเภทโมเดล	การสร้างวิดีโอด้วย AI
โหมดการสร้าง	ข้อความเป็นวิดีโอ (T2V), ภาพเป็นวิดีโอ (I2V), อ้างอิงเป็นวิดีโอ (R2V)
ประเภทอินพุต	ข้อความ, ภาพ, สื่ออ้างอิง
ประเภทเอาต์พุต	วิดีโอ
ความละเอียด	รองรับ 720p และ 1080p
ความยาววิดีโอ	3–15 วินาที
อัตราส่วนภาพ	16:9, 9:16, 1:1, 4:3, 3:4, 4:5, 5:4, 9:21, 21:9
ความยาวพรอมต์	สูงสุด 5,000 อักขระที่ไม่ใช่ภาษาจีน
การใช้งานเชิงพาณิชย์	รองรับผ่านพาร์ตเนอร์ API
โฟกัสหลัก	การสร้างวิดีโอเชิงภาพยนตร์พร้อมเสียงที่ซิงก์และความสม่ำเสมอของการเคลื่อนไหว

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

HappyHorse 1.1 คืออะไร?

HappyHorse 1.1 เป็นโมเดลสร้างวิดีโอแบบมัลติโหมด ออกแบบเพื่อการสร้างคอนเทนต์ระดับมืออาชีพ การโฆษณา ภาพยนตร์สั้น การผลิตคอนเทนต์บนโซเชียลมีเดีย และการเล่าเรื่อง โดยต่อยอดขีดความสามารถจาก HappyHorse 1.0—ซึ่งได้รับความสนใจอย่างมากหลังจัดอันดับสูงในการประเมินการสร้างวิดีโอจากหน่วยงานอิสระ—ด้วยความสอดคล้องของฉากที่แข็งแรงขึ้นและความเที่ยงตรงด้านภาพที่ดีขึ้น

แตกต่างจากโมเดลวิดีโอจำนวนมากที่สร้างวิดีโอเงียบก่อนแล้วค่อยเพิ่มเสียงในภายหลัง สถาปัตยกรรมของ HappyHorse เป็นที่รู้จักจากการสร้างวิดีโอและเสียงร่วมกัน ช่วยรักษาความแม่นยำของการซิงค์ริมฝีปากและความสอดคล้องระหว่างภาพและเสียง

ความสามารถหลักของ Happy Horse 1.1 API

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

Happy Horse 1.1 สามารถแปลงพรอมต์ที่ละเอียดเป็นวิดีโอสั้นที่สร้างด้วย AI ด้วยความเข้าใจเชิงความหมายที่แข็งแรงและการยึดตามพรอมต์ที่แม่นยำยิ่งขึ้น รองรับพรอมต์หลายภาษา และเหมาะสำหรับฉากเชิงภาพยนตร์ ภาพผลิตภัณฑ์ คลิปโซเชียลมีเดีย วิดีโอเล่าเรื่อง และการสร้างแนวคิดเชิงสร้างสรรค์

การสร้างวิดีโอจากภาพ

ด้วยการรองรับภาพเป็นวิดีโอ Happy Horse 1.1 สามารถทำให้ภาพนิ่งเคลื่อนไหว โดยคงรายละเอียดภาพสำคัญ เช่น เอกลักษณ์ตัวละคร ลักษณะผลิตภัณฑ์ องค์ประกอบฉากหลัง และสไตล์ศิลป์ เหมาะสำหรับวิดีโออีคอมเมิร์ซ แอนิเมชันตัวละคร เดโมแอป โฆษณาโซเชียลมีเดีย และคอนเทนต์ภาพของแบรนด์

การสร้างวิดีโอจากอ้างอิง

Happy Horse 1.1 รองรับการสร้างวิดีโอแบบอิงอ้างอิงโดยใช้หลายภาพ ตามหน้า HappyHorse-1.1 ของ Kie.ai เวิร์กโฟลว์อ้างอิงเป็นวิดีโอสามารถใช้ภาพอ้างอิงได้สูงสุด 9 ภาพ ช่วยให้นักพัฒนากำหนดรูปลักษณ์ของวัตถุ องค์ประกอบฉาก สไตล์ และทิศทางสร้างสรรค์ได้แม่นยำยิ่งขึ้น

การควบคุมวิดีโอที่ยืดหยุ่น

Happy Horse 1.1 รองรับการตั้งค่าทั่วไปในการผลิต รวมถึงตัวเลือกความละเอียด 720p และ 1080p อัตราส่วนภาพหลากหลาย เช่น 16:9, 9:16, 1:1, 4:3, 3:4, 4:5, 5:4, 9:21 และ 21:9 และความยาววิดีโอตั้งแต่ 3 ถึง 15 วินาที ทำให้เหมาะทั้งสำหรับวิดีโอแนวนอน คอนเทนต์แนวตั้งแบบสั้น โพสต์สี่เหลี่ยมบนโซเชียลมีเดีย และพรีวิวเชิงภาพยนตร์แบบอัลตร้าไวด์

การเคลื่อนไหวและความสม่ำเสมอที่ดีขึ้น

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

เปรียบเทียบ Happy Horse 1.1 API กับ Seedance 2.0 API

คุณสมบัติ	Happy Horse 1.1 API	Seedance 2.0 API
เหมาะสำหรับ	ความสม่ำเสมอของตัวละคร, อ้างอิงเป็นวิดีโอ, การสร้างวิดีโอที่ควบคุมโดยแบรนด์	ข้อความสู่วิดีโอเชิงภาพยนตร์, การสร้างวิดีโอแบบมัลติโหมด, เวิร์กโฟลว์ภาพและเสียง
เวิร์กโฟลว์หลัก	ข้อความเป็นวิดีโอ, ภาพเป็นวิดีโอ, อ้างอิงเป็นวิดีโอ	การสร้างบนพื้นฐานข้อความ ภาพ วิดีโอ และเสียง ขึ้นอยู่กับการผสานระบบ
รองรับอ้างอิง	ใช้ภาพอ้างอิงได้สูงสุด 9 ภาพบน Kie.ai	คู่มือ Seedance 2.0 ของ CometAPI อธิบายการอ้างอิงแบบมัลติโหมดที่กว้างกว่า รวมถึงภาพ วิดีโอ และเสียง
ระยะเวลาผลลัพธ์	3-15 วินาที	โดยทั่วไป 4-15 วินาที
ความละเอียด	720p และ 1080p	แตกต่างตามระดับ; เอกสารของ CometAPI ระบุ 480p/720p และสูงสุดถึง 2K ในบางระดับ
จุดเด่น	รักษาตัวละคร สไตล์ วัตถุ และเจตนาของภาพอ้างอิง	การเคลื่อนไหวสไตล์ผู้กำกับ การสร้างวิดีโอและเสียงแบบเนทีฟ การตีความพรอมต์เชิงภาพยนตร์
การใช้งานที่แนะนำ	เดโมผลิตภัณฑ์, ตัวละครเสมือน, วิดีโอแบรนด์, ฉากเล่าเรื่อง, ทรัพย์สินภาพที่สม่ำเสมอ	วิดีโอการตลาด, ภาพยนตร์สั้นเชิงภาพยนตร์, คลิปโซเชียลมีเดีย, คอนเทนต์ที่ซิงก์เสียง

เลือกใช้ Happy Horse 1.1 API เมื่อเวิร์กโฟลว์ของคุณขึ้นอยู่กับความสม่ำเสมอทางภาพ การควบคุมด้วยภาพอ้างอิง การคงเอกลักษณ์ตัวละคร หรือความสามารถในการทำซ้ำที่ปลอดภัยต่อแบรนด์ เลือก Seedance 2.0 API เมื่อคุณต้องการการสร้างภาพและเสียงที่แข็งแรงกว่า การตีความพรอมต์เชิงภาพยนตร์ หรือทิศทางมัลติโหมดที่ซับซ้อนกว่า

วิธีสร้างด้วย HappyHorse 1.1 API บน CometAPI

ขั้นตอนที่ 1: รับคีย์ API ของคุณ

สร้างบัญชี CometAPI สร้างคีย์ API และยืนยันตัวระบุโมเดล HappyHorse 1.1 (happyhorse-1.1) ที่ใช้งานอยู่ผ่านแพลตฟอร์ม และตรวจดูเอกสาร HappyHorse API

ขั้นตอนที่ 2: พรอมต์

ระบุพรอมต์ข้อความ อัปโหลดภาพ หรือเพิ่มภาพอ้างอิงเพื่อกำกับกระบวนการสร้างวิดีโอของ HappyHorse-1.1

ขั้นตอนที่ 3: สร้างวิดีโอ

สร้างงานข้อความเป็นวิดีโอของ HappyHorse ผ่าน CometAPI ด้วย POST /v1/videos จากนั้นโพลงานและดาวน์โหลดไฟล์ MP4 ที่เสร็จสมบูรณ์ หากงานยังทำงานอยู่ API จะส่งกลับข้อผิดพลาด JSON แทนไบต์วิดีโอ

คุณสามารถสร้างอะไรได้บ้างด้วย Happy Horse 1.1 API บน CometAPI?

แอปสร้างวิดีโอ AI

สร้างแพลตฟอร์มสร้างวิดีโอ AI แบบครบวงจรที่รองรับข้อความเป็นวิดีโอ ภาพเป็นวิดีโอ และอ้างอิงเป็นวิดีโอผ่านเลเยอร์ API เดียว

วิดีโอเดโมผลิตภัณฑ์

แปลงภาพผลิตภัณฑ์ให้เป็นคลิปเคลื่อนไหวสั้นสำหรับอีคอมเมิร์ซ การเปิดตัว SaaS แอปมือถือ การนำเสนอฮาร์ดแวร์ และโฆษณาดิจิทัล

การเล่าเรื่องที่คงเอกลักษณ์ตัวละคร

สร้างวิดีโอเชิงเนื้อเรื่อง อินฟลูเอนเซอร์เสมือน ตัวละครแบรนด์ และคลิปเรื่องราวบนโซเชียล โดยคงเอกลักษณ์ตัวละครและสไตล์ภาพให้สม่ำเสมอ

คอนเทนต์แบรนด์และการตลาด

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

การทำต้นแบบเชิงสร้างสรรค์

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

ทำไมควรเลือก Happy Horse 1.1 API บน CometAPI?

API เดียวสำหรับโมเดล 500+ รายการ

CometAPI มอบการเข้าถึงแบบรวมสำหรับโมเดล AI 500+ รายการ รวมถึงโมเดลสร้างข้อความ ภาพ เสียง และวิดีโอ นักพัฒนาสามารถผสานเพียงครั้งเดียวและสลับโมเดลได้โดยไม่ต้องปรับแอปพลิเคชันใหม่

ลดภาระการผสานระบบ

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

เปรียบเทียบโมเดลได้ง่ายขึ้น

Happy Horse 1.1 สามารถทดสอบเคียงข้างโมเดลวิดีโออื่น เช่น Seedance, Kling, Veo และโมเดลสไตล์ Sora เพื่อช่วยให้ทีมเปรียบเทียบคุณภาพ ต้นทุน ระยะหน่วง และประสิทธิภาพพรอมต์ก่อนเลือกโมเดลสำหรับงานผลิตจริง

สร้างขึ้นเพื่อเวิร์กโฟลว์วิดีโอระดับผลิตจริง

CometAPI รองรับรูปแบบการสร้างวิดีโอแบบอะซิงก์ การโพลงาน การติดตามการใช้งาน และการกำหนดเส้นทางโมเดล ทำให้ง่ายต่อการขยับจากต้นแบบสู่การผลิตจริง

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

API

คัดลอกเอนด์พอยต์และตัวอย่างโค้ดที่ใช้งานได้จริง จากนั้นเปิดเอกสารอ้างอิง API ฉบับเต็มเมื่อต้องการพารามิเตอร์ทั้งหมด

API เดียว เข้าถึงโมเดลพร้อมใช้งานจริง

ยืนยันตัวตนเพียงครั้งเดียว เรียกใช้เอนด์พอยต์ของโมเดล และคงเวิร์กโฟลว์การเรียกเก็บเงินและการตรวจสอบแบบเดียวกันในทุกผู้ให้บริการ

POST/v1/videosGET/v1/videos/{task_id}/contentGET/v1/videos/{task_id}

โค้ดตัวอย่างและ API สำหรับ Happy Horse 1.1

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

POST

/v1/videos

GET

/v1/videos/{task_id}/content

GET

/v1/videos/{task_id}

# Create a video with happyhorse-1.1
# Step 1: Submit the video generation request
echo "Submitting video generation request..."
response=$(curl -s https://api.cometapi.com/v1/videos \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -F "model=happyhorse-1.1" \
  -F "prompt=A close-up cinematic shot of a ceramic coffee cup on a wooden table. Steam rises slowly while morning light moves across the background." \
  -F "seconds=3" \
  -F "size=1920x1080")

echo "Response: $response"

# Extract video_id from response (handle JSON with spaces like "id": "xxx")
video_id=$(echo "$response" | tr -d '
' | sed 's/.*"id"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/')
echo "Video ID: $video_id"

# Step 2: Poll for progress until 100%
echo ""
echo "Checking video generation progress..."
while true; do
  status_response=$(curl -s "https://api.cometapi.com/v1/videos/$video_id" \
    -H "Authorization: Bearer $COMETAPI_KEY")

  progress=$(echo "$status_response" | grep -o '"progress"[[:space:]]*:[[:space:]]*"\?[^",}]*"\?' | head -1 | sed 's/.*:[[:space:]]*"\?//;s/"$//')
  status=$(echo "$status_response" | grep -o '"status"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 | sed 's/.*"status"[[:space:]]*:[[:space:]]*"//;s/"$//')

  echo "Progress: $progress, Status: $status"

  if [ "$status" = "FAILURE" ] || [ "$status" = "failed" ] || [ "$status" = "error" ]; then
    echo "Video generation failed!"
    exit 1
  fi

  if [ "$progress" = "100%" ] || [ "$progress" = "100" ] || [ "$status" = "completed" ] || [ "$status" = "success" ]; then
    echo "Video generation completed!"
    break
  fi

  sleep 10
done

# Step 3: Download the video to output directory
echo ""
echo "Downloading video to ./output/$video_id.mp4..."
mkdir -p ./output
curl -s "https://api.cometapi.com/v1/videos/$video_id/content" \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -o "./output/$video_id.mp4"

if [ -f "./output/$video_id.mp4" ]; then
  echo "Video saved to ./output/$video_id.mp4"
  ls -la "./output/$video_id.mp4"
else
  echo "Failed to download video"
  exit 1
fi

cURL Code Example

# Create a video with happyhorse-1.1
# Step 1: Submit the video generation request
echo "Submitting video generation request..."
response=$(curl -s https://api.cometapi.com/v1/videos \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -F "model=happyhorse-1.1" \
  -F "prompt=A close-up cinematic shot of a ceramic coffee cup on a wooden table. Steam rises slowly while morning light moves across the background." \
  -F "seconds=3" \
  -F "size=1920x1080")

echo "Response: $response"

# Extract video_id from response (handle JSON with spaces like "id": "xxx")
video_id=$(echo "$response" | tr -d '\n' | sed 's/.*"id"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/')
echo "Video ID: $video_id"

# Step 2: Poll for progress until 100%
echo ""
echo "Checking video generation progress..."
while true; do
  status_response=$(curl -s "https://api.cometapi.com/v1/videos/$video_id" \
    -H "Authorization: Bearer $COMETAPI_KEY")

  progress=$(echo "$status_response" | grep -o '"progress"[[:space:]]*:[[:space:]]*"\?[^",}]*"\?' | head -1 | sed 's/.*:[[:space:]]*"\?//;s/"$//')
  status=$(echo "$status_response" | grep -o '"status"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 | sed 's/.*"status"[[:space:]]*:[[:space:]]*"//;s/"$//')

  echo "Progress: $progress, Status: $status"

  if [ "$status" = "FAILURE" ] || [ "$status" = "failed" ] || [ "$status" = "error" ]; then
    echo "Video generation failed!"
    exit 1
  fi

  if [ "$progress" = "100%" ] || [ "$progress" = "100" ] || [ "$status" = "completed" ] || [ "$status" = "success" ]; then
    echo "Video generation completed!"
    break
  fi

  sleep 10
done

# Step 3: Download the video to output directory
echo ""
echo "Downloading video to ./output/$video_id.mp4..."
mkdir -p ./output
curl -s "https://api.cometapi.com/v1/videos/$video_id/content" \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -o "./output/$video_id.mp4"

if [ -f "./output/$video_id.mp4" ]; then
  echo "Video saved to ./output/$video_id.mp4"
  ls -la "./output/$video_id.mp4"
else
  echo "Failed to download video"
  exit 1
fi

Python Code Example

# Create a video with happyhorse-1.1 using raw HTTP requests
import os
import time
import requests

api_key = os.environ.get("COMETAPI_KEY")
base_url = "https://api.cometapi.com/v1"
headers = {"Authorization": f"Bearer {api_key}"}
prompt = "A close-up cinematic shot of a ceramic coffee cup on a wooden table. Steam rises slowly while morning light moves across the background."

# Step 1: Submit the video generation request
print("Submitting video generation request...")
response = requests.post(
    f"{base_url}/videos",
    headers=headers,
    files={
        "model": (None, "happyhorse-1.1"),
        "prompt": (None, prompt),
        "seconds": (None, "3"),
        "size": (None, "1920x1080"),
    },
)

result = response.json()
print(f"Response: {result}")

video_id = result.get("id") or result.get("task_id")
print(f"Video ID: {video_id}")

# Step 2: Poll for progress until 100%
print("\nChecking video generation progress...")
while True:
    try:
        status_response = requests.get(f"{base_url}/videos/{video_id}", headers=headers)
        status_result = status_response.json()

        data = status_result.get("data") or status_result
        progress = data.get("progress", "0%")
        status = data.get("status", "unknown")

        print(f"Progress: {progress}, Status: {status}")

        if status in ["FAILURE", "failed", "error"]:
            print("Video generation failed!")
            print(status_result)
            exit(1)

        if progress == "100%" or progress == 100 or status in ["completed", "success"]:
            print("Video generation completed!")
            break
    except Exception as e:
        print(f"Temporary error: {e}, retrying...")

    time.sleep(10)

# Step 3: Download the video to output directory
print(f"\nDownloading video to ./output/{video_id}.mp4...")
os.makedirs("./output", exist_ok=True)

video_response = requests.get(f"{base_url}/videos/{video_id}/content", headers=headers)

output_path = f"./output/{video_id}.mp4"
with open(output_path, "wb") as f:
    f.write(video_response.content)

if os.path.exists(output_path):
    file_size = os.path.getsize(output_path)
    print(f"Video saved to {output_path}")
    print(f"File size: {file_size} bytes")
else:
    print("Failed to download video")
    exit(1)

JavaScript Code Example

// Create a video with happyhorse-1.1 using raw HTTP requests
import fs from "fs";
import path from "path";

const apiKey = process.env.COMETAPI_KEY;
const baseUrl = "https://api.cometapi.com/v1";
const headers = { Authorization: `Bearer ${apiKey}` };
const prompt = "A close-up cinematic shot of a ceramic coffee cup on a wooden table. Steam rises slowly while morning light moves across the background.";

function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

// Step 1: Submit the video generation request
console.log("Submitting video generation request...");
const formData = new FormData();
formData.append("model", "happyhorse-1.1");
formData.append("prompt", prompt);
formData.append("seconds", "3");
formData.append("size", "1920x1080");

const submitResponse = await fetch(`${baseUrl}/videos`, {
  method: "POST",
  headers,
  body: formData,
});

const result = await submitResponse.json();
console.log("Response:", JSON.stringify(result, null, 2));

const videoId = result.id || result.task_id;
console.log("Video ID:", videoId);

// Step 2: Poll for progress until 100%
console.log("\nChecking video generation progress...");
while (true) {
  try {
    const statusResponse = await fetch(`${baseUrl}/videos/${videoId}`, { headers });
    const statusResult = await statusResponse.json();
    const data = statusResult.data || statusResult;
    const progress = data.progress || "0%";
    const status = data.status || "unknown";

    console.log(`Progress: ${progress}, Status: ${status}`);

    if (status === "FAILURE" || status === "failed" || status === "error") {
      console.log("Video generation failed!");
      console.log(JSON.stringify(statusResult, null, 2));
      process.exit(1);
    }

    if (progress === "100%" || progress === 100 || status === "completed" || status === "success") {
      console.log("Video generation completed!");
      break;
    }
  } catch (e) {
    console.log(`Temporary error: ${e.message}, retrying...`);
  }

  await sleep(10000);
}

// Step 3: Download the video to output directory
console.log(`\nDownloading video to ./output/${videoId}.mp4...`);
fs.mkdirSync("./output", { recursive: true });

const videoResponse = await fetch(`${baseUrl}/videos/${videoId}/content`, { headers });
const outputPath = path.join("./output", `${videoId}.mp4`);
fs.writeFileSync(outputPath, Buffer.from(await videoResponse.arrayBuffer()));

if (fs.existsSync(outputPath)) {
  const stats = fs.statSync(outputPath);
  console.log(`Video saved to ${outputPath}`);
  console.log(`File size: ${stats.size} bytes`);
} else {
  console.log("Failed to download video");
  process.exit(1);
}

ความสามารถ

ตรวจสอบข้อมูลสำคัญของโมเดลก่อนเลือกสถาปัตยกรรมหรือประเมินภาระงานในโปรดักชัน

ความสามารถที่รองรับ

ฟีเจอร์ที่ส่งกลับโดย API ของโมเดลปัจจุบัน

text-to-video

image-to-video

อินพุตและเอาต์พุต

อินพุต

text

เอาต์พุต

video

โปรไฟล์การใช้งานจริง

ผู้ให้บริการ: Aliyun
บริบท: ขึ้นอยู่กับโมเดล
การใช้งานเชิงพาณิชย์: รองรับ

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

ใช้ Happy Horse 1.1 สำหรับเวิร์กโฟลว์ระดับโปรดักชันที่เหมาะกับความสามารถด้าน video จากนั้นเปรียบเทียบทางเลือกอื่นก่อนตัดสินใจเชื่อมต่อระยะยาว

แนวคิดข้อความเป็นวิดีโอและคอนเทนต์โซเชียล

การสาธิตสินค้าและสตอรีบอร์ดสไตล์ภาพยนตร์

การเคลื่อนไหวจากภาพสู่วิดีโอและการทำซ้ำเชิงสร้างสรรค์

โมเดลอื่น ๆ

เปรียบเทียบโมเดลอื่น ๆ ที่มีให้บริการผ่าน CometAPI ในด้านคุณภาพ ความหน่วง ความสามารถ และราคา

เปิดการเปรียบเทียบโมเดล →

MiniMax

MiniMax H3 Max

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

ดูโมเดล

xAI

Grok Imagine Video

สร้างวิดีโอจากพรอมต์ข้อความ แปลงภาพนิ่งให้เคลื่อนไหว หรือแก้ไขวิดีโอที่มีอยู่ด้วยภาษาธรรมชาติ API รองรับการปรับแต่งระยะเวลา อัตราส่วนภาพ และความละเอียดสำหรับวิดีโอที่สร้างขึ้น — โดย SDK จะจัดการการโพลลิงแบบอะซิงโครนัสให้อัตโนมัติ

ดูโมเดล

Aliyun

Wan3.0

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

ดูโมเดล

MiniMax

MiniMax H3

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

ดูโมเดล

Flux

Flux 3

FLUX 3 - แบบจำลองโลกจริง: มุ่งสู่แบบจำลองโฟลว์แบบหลายโมดาลิตีในฐานะกระดูกสันหลังของปัญญาด้านการมองเห็น.

สำรวจ API ของ Gen4.5

เวลาทำงาน

ตรวจสอบข้อมูล heartbeat แบบเรียลไทม์ ความพร้อมใช้งานของเอนด์พอยต์ และเวลาตอบสนองที่วัดได้จริงก่อนใช้งานจริง

เวอร์ชัน

ตรวจสอบตัวระบุโมเดลที่มีให้ใช้งานก่อนกำหนดเวอร์ชันสำหรับการเชื่อมต่อจริง

happyhorse-1.1

อัปเดต

ติดตามการเปลี่ยนแปลงสำคัญด้านความพร้อมใช้งาน ราคา และความสามารถของ Happy Horse 1.1 โดยยังคงรักษาหน้าโมเดลที่คงที่ไว้

บันทึกการเปลี่ยนแปลงโมเดล

หน้าเดียวที่ดีขึ้นเรื่อย ๆ เมื่อเวลาผ่านไป

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

Jun 28, 2026

ยืนยันความพร้อมใช้งานของ API แล้ว

Happy Horse 1.1 พร้อมใช้งานผ่านแค็ตตาล็อกโมเดลและเอกสาร API ของ CometAPI

ปัจจุบัน

ข้อมูลแบบเรียลไทม์

ซิงค์ราคาและข้อจำกัดจากแค็ตตาล็อกแล้ว

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

Jun 23, 2026

สร้างเอนทิตีโมเดลถาวรแล้ว

ผู้ให้บริการและ slug ของโมเดลจะสร้าง URL มาตรฐานถาวร โดยเนื้อหาและข้อมูลในอนาคตจะยังคงอัปเดตอยู่ในหน้านี้

สำรวจต่อ

เปรียบเทียบโมเดลและค้นคว้าต่อ

Aliyun

พร้อมใช้งาน

happyhorse-1.1

Happy Horse 1.1 API

ราคาเริ่มต้น

$0.112 / วินาที

คิดค่าบริการตามการใช้งาน

สถานะ API

พร้อมใช้งาน

เอนด์พอยต์สำหรับโปรดักชัน

เวลาตอบสนอง

รองรับการทำงานแบบ async

เวลาตอบสนอง API ที่วัดได้จริง

วันที่เผยแพร่

Jun 28, 2026

Aliyun

พื้นที่ทดลอง

ราคา

ทดสอบ 5 วินาที

$0.5600

ค่าใช้จ่ายโดยประมาณในการใช้งาน CometAPI

ทดสอบ 10 วินาที

$1.12

ค่าใช้จ่ายโดยประมาณในการใช้งาน CometAPI

ทดสอบ 15 วินาที

$1.68

ค่าใช้จ่ายโดยประมาณในการใช้งาน CometAPI

Happyhorse Video Generation Pricing

Pricing (Per Second)

Model	720p	1080p
`happyhorse-1.1`	$0.112	$0.144

💡 Billed per second. Total cost = price per second × video duration (seconds).

สรุปโมเดล

อัตลักษณ์ที่คงที่

Happy Horse 1.1 คืออะไร

อัตลักษณ์หลักของโมเดลยังคงเดิม แม้ว่าราคาและข้อจำกัดจะเปลี่ยนแปลง

ข้อมูลโมเดลแบบเรียลไทม์

ภาพรวมแคตตาล็อกปัจจุบัน

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

พร้อมใช้งาน

ราคาเริ่มต้น

$0.112 / วินาที

บริบท

ดูความสามารถ

วันที่ของแคตตาล็อก

Jun 28, 2026

ภาพรวม

ข้อมูลจำเพาะทางเทคนิคของ HappyHorse 1.1

รายการ	HappyHorse 1.1
ผู้ให้บริการ	Alibaba
ประเภทโมเดล	การสร้างวิดีโอด้วย AI
โหมดการสร้าง	ข้อความเป็นวิดีโอ (T2V), ภาพเป็นวิดีโอ (I2V), อ้างอิงเป็นวิดีโอ (R2V)
ประเภทอินพุต	ข้อความ, ภาพ, สื่ออ้างอิง
ประเภทเอาต์พุต	วิดีโอ
ความละเอียด	รองรับ 720p และ 1080p
ความยาววิดีโอ	3–15 วินาที
อัตราส่วนภาพ	16:9, 9:16, 1:1, 4:3, 3:4, 4:5, 5:4, 9:21, 21:9
ความยาวพรอมต์	สูงสุด 5,000 อักขระที่ไม่ใช่ภาษาจีน
การใช้งานเชิงพาณิชย์	รองรับผ่านพาร์ตเนอร์ API
โฟกัสหลัก	การสร้างวิดีโอเชิงภาพยนตร์พร้อมเสียงที่ซิงก์และความสม่ำเสมอของการเคลื่อนไหว

HappyHorse 1.1 คืออะไร?

ความสามารถหลักของ Happy Horse 1.1 API

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

การสร้างวิดีโอจากภาพ

การสร้างวิดีโอจากอ้างอิง

การควบคุมวิดีโอที่ยืดหยุ่น

การเคลื่อนไหวและความสม่ำเสมอที่ดีขึ้น

เปรียบเทียบ Happy Horse 1.1 API กับ Seedance 2.0 API

คุณสมบัติ	Happy Horse 1.1 API	Seedance 2.0 API
เหมาะสำหรับ	ความสม่ำเสมอของตัวละคร, อ้างอิงเป็นวิดีโอ, การสร้างวิดีโอที่ควบคุมโดยแบรนด์	ข้อความสู่วิดีโอเชิงภาพยนตร์, การสร้างวิดีโอแบบมัลติโหมด, เวิร์กโฟลว์ภาพและเสียง
เวิร์กโฟลว์หลัก	ข้อความเป็นวิดีโอ, ภาพเป็นวิดีโอ, อ้างอิงเป็นวิดีโอ	การสร้างบนพื้นฐานข้อความ ภาพ วิดีโอ และเสียง ขึ้นอยู่กับการผสานระบบ
รองรับอ้างอิง	ใช้ภาพอ้างอิงได้สูงสุด 9 ภาพบน Kie.ai	คู่มือ Seedance 2.0 ของ CometAPI อธิบายการอ้างอิงแบบมัลติโหมดที่กว้างกว่า รวมถึงภาพ วิดีโอ และเสียง
ระยะเวลาผลลัพธ์	3-15 วินาที	โดยทั่วไป 4-15 วินาที
ความละเอียด	720p และ 1080p	แตกต่างตามระดับ; เอกสารของ CometAPI ระบุ 480p/720p และสูงสุดถึง 2K ในบางระดับ
จุดเด่น	รักษาตัวละคร สไตล์ วัตถุ และเจตนาของภาพอ้างอิง	การเคลื่อนไหวสไตล์ผู้กำกับ การสร้างวิดีโอและเสียงแบบเนทีฟ การตีความพรอมต์เชิงภาพยนตร์
การใช้งานที่แนะนำ	เดโมผลิตภัณฑ์, ตัวละครเสมือน, วิดีโอแบรนด์, ฉากเล่าเรื่อง, ทรัพย์สินภาพที่สม่ำเสมอ	วิดีโอการตลาด, ภาพยนตร์สั้นเชิงภาพยนตร์, คลิปโซเชียลมีเดีย, คอนเทนต์ที่ซิงก์เสียง

วิธีสร้างด้วย HappyHorse 1.1 API บน CometAPI

ขั้นตอนที่ 1: รับคีย์ API ของคุณ

ขั้นตอนที่ 2: พรอมต์

ขั้นตอนที่ 3: สร้างวิดีโอ

คุณสามารถสร้างอะไรได้บ้างด้วย Happy Horse 1.1 API บน CometAPI?

แอปสร้างวิดีโอ AI

วิดีโอเดโมผลิตภัณฑ์

การเล่าเรื่องที่คงเอกลักษณ์ตัวละคร

คอนเทนต์แบรนด์และการตลาด

การทำต้นแบบเชิงสร้างสรรค์

ทำไมควรเลือก Happy Horse 1.1 API บน CometAPI?

API เดียวสำหรับโมเดล 500+ รายการ

ลดภาระการผสานระบบ

เปรียบเทียบโมเดลได้ง่ายขึ้น

สร้างขึ้นเพื่อเวิร์กโฟลว์วิดีโอระดับผลิตจริง

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

API

API เดียว เข้าถึงโมเดลพร้อมใช้งานจริง

POST/v1/videosGET/v1/videos/{task_id}/contentGET/v1/videos/{task_id}

โค้ดตัวอย่างและ API สำหรับ Happy Horse 1.1

POST

/v1/videos

GET

/v1/videos/{task_id}/content

GET

/v1/videos/{task_id}

# Create a video with happyhorse-1.1
# Step 1: Submit the video generation request
echo "Submitting video generation request..."
response=$(curl -s https://api.cometapi.com/v1/videos \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -F "model=happyhorse-1.1" \
  -F "prompt=A close-up cinematic shot of a ceramic coffee cup on a wooden table. Steam rises slowly while morning light moves across the background." \
  -F "seconds=3" \
  -F "size=1920x1080")

echo "Response: $response"

# Extract video_id from response (handle JSON with spaces like "id": "xxx")
video_id=$(echo "$response" | tr -d '
' | sed 's/.*"id"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/')
echo "Video ID: $video_id"

# Step 2: Poll for progress until 100%
echo ""
echo "Checking video generation progress..."
while true; do
  status_response=$(curl -s "https://api.cometapi.com/v1/videos/$video_id" \
    -H "Authorization: Bearer $COMETAPI_KEY")

  progress=$(echo "$status_response" | grep -o '"progress"[[:space:]]*:[[:space:]]*"\?[^",}]*"\?' | head -1 | sed 's/.*:[[:space:]]*"\?//;s/"$//')
  status=$(echo "$status_response" | grep -o '"status"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 | sed 's/.*"status"[[:space:]]*:[[:space:]]*"//;s/"$//')

  echo "Progress: $progress, Status: $status"

  if [ "$status" = "FAILURE" ] || [ "$status" = "failed" ] || [ "$status" = "error" ]; then
    echo "Video generation failed!"
    exit 1
  fi

  if [ "$progress" = "100%" ] || [ "$progress" = "100" ] || [ "$status" = "completed" ] || [ "$status" = "success" ]; then
    echo "Video generation completed!"
    break
  fi

  sleep 10
done

# Step 3: Download the video to output directory
echo ""
echo "Downloading video to ./output/$video_id.mp4..."
mkdir -p ./output
curl -s "https://api.cometapi.com/v1/videos/$video_id/content" \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -o "./output/$video_id.mp4"

if [ -f "./output/$video_id.mp4" ]; then
  echo "Video saved to ./output/$video_id.mp4"
  ls -la "./output/$video_id.mp4"
else
  echo "Failed to download video"
  exit 1
fi

cURL Code Example

# Create a video with happyhorse-1.1
# Step 1: Submit the video generation request
echo "Submitting video generation request..."
response=$(curl -s https://api.cometapi.com/v1/videos \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -F "model=happyhorse-1.1" \
  -F "prompt=A close-up cinematic shot of a ceramic coffee cup on a wooden table. Steam rises slowly while morning light moves across the background." \
  -F "seconds=3" \
  -F "size=1920x1080")

echo "Response: $response"

# Extract video_id from response (handle JSON with spaces like "id": "xxx")
video_id=$(echo "$response" | tr -d '\n' | sed 's/.*"id"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/')
echo "Video ID: $video_id"

# Step 2: Poll for progress until 100%
echo ""
echo "Checking video generation progress..."
while true; do
  status_response=$(curl -s "https://api.cometapi.com/v1/videos/$video_id" \
    -H "Authorization: Bearer $COMETAPI_KEY")

  progress=$(echo "$status_response" | grep -o '"progress"[[:space:]]*:[[:space:]]*"\?[^",}]*"\?' | head -1 | sed 's/.*:[[:space:]]*"\?//;s/"$//')
  status=$(echo "$status_response" | grep -o '"status"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 | sed 's/.*"status"[[:space:]]*:[[:space:]]*"//;s/"$//')

  echo "Progress: $progress, Status: $status"

  if [ "$status" = "FAILURE" ] || [ "$status" = "failed" ] || [ "$status" = "error" ]; then
    echo "Video generation failed!"
    exit 1
  fi

  if [ "$progress" = "100%" ] || [ "$progress" = "100" ] || [ "$status" = "completed" ] || [ "$status" = "success" ]; then
    echo "Video generation completed!"
    break
  fi

  sleep 10
done

# Step 3: Download the video to output directory
echo ""
echo "Downloading video to ./output/$video_id.mp4..."
mkdir -p ./output
curl -s "https://api.cometapi.com/v1/videos/$video_id/content" \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -o "./output/$video_id.mp4"

if [ -f "./output/$video_id.mp4" ]; then
  echo "Video saved to ./output/$video_id.mp4"
  ls -la "./output/$video_id.mp4"
else
  echo "Failed to download video"
  exit 1
fi

Python Code Example

# Create a video with happyhorse-1.1 using raw HTTP requests
import os
import time
import requests

api_key = os.environ.get("COMETAPI_KEY")
base_url = "https://api.cometapi.com/v1"
headers = {"Authorization": f"Bearer {api_key}"}
prompt = "A close-up cinematic shot of a ceramic coffee cup on a wooden table. Steam rises slowly while morning light moves across the background."

# Step 1: Submit the video generation request
print("Submitting video generation request...")
response = requests.post(
    f"{base_url}/videos",
    headers=headers,
    files={
        "model": (None, "happyhorse-1.1"),
        "prompt": (None, prompt),
        "seconds": (None, "3"),
        "size": (None, "1920x1080"),
    },
)

result = response.json()
print(f"Response: {result}")

video_id = result.get("id") or result.get("task_id")
print(f"Video ID: {video_id}")

# Step 2: Poll for progress until 100%
print("\nChecking video generation progress...")
while True:
    try:
        status_response = requests.get(f"{base_url}/videos/{video_id}", headers=headers)
        status_result = status_response.json()

        data = status_result.get("data") or status_result
        progress = data.get("progress", "0%")
        status = data.get("status", "unknown")

        print(f"Progress: {progress}, Status: {status}")

        if status in ["FAILURE", "failed", "error"]:
            print("Video generation failed!")
            print(status_result)
            exit(1)

        if progress == "100%" or progress == 100 or status in ["completed", "success"]:
            print("Video generation completed!")
            break
    except Exception as e:
        print(f"Temporary error: {e}, retrying...")

    time.sleep(10)

# Step 3: Download the video to output directory
print(f"\nDownloading video to ./output/{video_id}.mp4...")
os.makedirs("./output", exist_ok=True)

video_response = requests.get(f"{base_url}/videos/{video_id}/content", headers=headers)

output_path = f"./output/{video_id}.mp4"
with open(output_path, "wb") as f:
    f.write(video_response.content)

if os.path.exists(output_path):
    file_size = os.path.getsize(output_path)
    print(f"Video saved to {output_path}")
    print(f"File size: {file_size} bytes")
else:
    print("Failed to download video")
    exit(1)

JavaScript Code Example

// Create a video with happyhorse-1.1 using raw HTTP requests
import fs from "fs";
import path from "path";

const apiKey = process.env.COMETAPI_KEY;
const baseUrl = "https://api.cometapi.com/v1";
const headers = { Authorization: `Bearer ${apiKey}` };
const prompt = "A close-up cinematic shot of a ceramic coffee cup on a wooden table. Steam rises slowly while morning light moves across the background.";

function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

// Step 1: Submit the video generation request
console.log("Submitting video generation request...");
const formData = new FormData();
formData.append("model", "happyhorse-1.1");
formData.append("prompt", prompt);
formData.append("seconds", "3");
formData.append("size", "1920x1080");

const submitResponse = await fetch(`${baseUrl}/videos`, {
  method: "POST",
  headers,
  body: formData,
});

const result = await submitResponse.json();
console.log("Response:", JSON.stringify(result, null, 2));

const videoId = result.id || result.task_id;
console.log("Video ID:", videoId);

// Step 2: Poll for progress until 100%
console.log("\nChecking video generation progress...");
while (true) {
  try {
    const statusResponse = await fetch(`${baseUrl}/videos/${videoId}`, { headers });
    const statusResult = await statusResponse.json();
    const data = statusResult.data || statusResult;
    const progress = data.progress || "0%";
    const status = data.status || "unknown";

    console.log(`Progress: ${progress}, Status: ${status}`);

    if (status === "FAILURE" || status === "failed" || status === "error") {
      console.log("Video generation failed!");
      console.log(JSON.stringify(statusResult, null, 2));
      process.exit(1);
    }

    if (progress === "100%" || progress === 100 || status === "completed" || status === "success") {
      console.log("Video generation completed!");
      break;
    }
  } catch (e) {
    console.log(`Temporary error: ${e.message}, retrying...`);
  }

  await sleep(10000);
}

// Step 3: Download the video to output directory
console.log(`\nDownloading video to ./output/${videoId}.mp4...`);
fs.mkdirSync("./output", { recursive: true });

const videoResponse = await fetch(`${baseUrl}/videos/${videoId}/content`, { headers });
const outputPath = path.join("./output", `${videoId}.mp4`);
fs.writeFileSync(outputPath, Buffer.from(await videoResponse.arrayBuffer()));

if (fs.existsSync(outputPath)) {
  const stats = fs.statSync(outputPath);
  console.log(`Video saved to ${outputPath}`);
  console.log(`File size: ${stats.size} bytes`);
} else {
  console.log("Failed to download video");
  process.exit(1);
}