HappyHorse 1.0

Alibaba ATH

# Meet Alibaba Happy Horse 1.0! 🐴 Welcome to Happy Horse 1.0, an AI video model that quickly turns text prompts into short clips.

Schema

Playground

First

0/5000

Your Generations

Showing the latest 30 generations here. Use the full gallery for everything else.

Open Full Gallery

Showcase

3 presets

HappyHorse 1.0 API# Meet Alibaba Happy Horse 1.0! 🐴 Welcome to Happy Horse 1.0, an AI video model that quickly turns text prompts into short clips.

POSThttps://kinovi.ai/api/v1/jobs/createTask

Quick Start

Generate a fresh API key to get a fully runnable script without replacing placeholders by hand.

#!/bin/bash
# Usage: chmod +x happyhorse1-0-kinovi.sh && ./happyhorse1-0-kinovi.sh

KINOVI_API_KEY="${KINOVI_API_KEY:?Set your API key: export KINOVI_API_KEY=your-api-key}"

# Submit task
RESPONSE=$(curl -s -X POST "https://kinovi.ai/api/v1/jobs/createTask" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $KINOVI_API_KEY" \
  -d '{
  "model": "happyhorse1.0",
  "inputs": {
    "prompt": "A young woman turns her head slowly toward camera, soft hair drift, warm golden-hour backlight, shallow depth of field",
    "resolution": "1280x720",
    "duration": "5",
    "outputResolution": "720p"
  }
}')

TASK_ID=$(echo "$RESPONSE" | grep -o '"taskId":"[^"]*"' | cut -d'"' -f4)
echo "Task created: $TASK_ID"

# Poll until complete
while true; do
  RESULT=$(curl -s "https://kinovi.ai/api/v1/jobs/recordInfo?taskId=$TASK_ID" \
    -H "Authorization: Bearer $KINOVI_API_KEY")
  STATUS=$(echo "$RESULT" | grep -o '"status":"[^"]*"' | head -1 | cut -d'"' -f4)

  case "$STATUS" in
    success) echo "Done!" && echo "$RESULT" | python3 -m json.tool 2>/dev/null || echo "$RESULT"; break ;;
    fail)    echo "Failed: $RESULT"; exit 1 ;;
    *)       echo "Status: $STATUS — waiting..." && sleep 2 ;;
  esac
done

// happyhorse1-0-kinovi.mjs — Usage: node happyhorse1-0-kinovi.mjs
const API_KEY = process.env.KINOVI_API_KEY ?? "your-api-key";

// 1. Submit task
const { taskId } = await fetch("https://kinovi.ai/api/v1/jobs/createTask", {
  method: "POST",
  headers: { "Content-Type": "application/json", Authorization: `Bearer ${API_KEY}` },
  body: JSON.stringify({
  "model": "happyhorse1.0",
  "inputs": {
    "prompt": "A young woman turns her head slowly toward camera, soft hair drift, warm golden-hour backlight, shallow depth of field",
    "resolution": "1280x720",
    "duration": "5",
    "outputResolution": "720p"
  }
}),
}).then((r) => r.json());

console.log("Task created:", taskId);

// 2. Poll until complete
while (true) {
  const data = await fetch(
    `https://kinovi.ai/api/v1/jobs/recordInfo?taskId=${taskId}`,
    { headers: { Authorization: `Bearer ${API_KEY}` } },
  ).then((r) => r.json());

  if (data.status === "success") {
    console.log("Done!", JSON.stringify(data.output, null, 2));
    break;
  }
  if (data.status === "fail") {
    console.error("Failed:", data.error);
    process.exit(1);
  }
  process.stdout.write(`Status: ${data.status} — waiting...\r`);
  await new Promise((r) => setTimeout(r, 2000));
}

# happyhorse1-0-kinovi.py — Usage: python happyhorse1-0-kinovi.py
import os
import time
import requests

API_KEY = os.environ.get("KINOVI_API_KEY", "your-api-key")
HEADERS = {"Authorization": f"Bearer {API_KEY}"}

# 1. Submit task
task_id = requests.post(
    "https://kinovi.ai/api/v1/jobs/createTask",
    headers=HEADERS,
    json={
  "model": "happyhorse1.0",
  "inputs": {
    "prompt": "A young woman turns her head slowly toward camera, soft hair drift, warm golden-hour backlight, shallow depth of field",
    "resolution": "1280x720",
    "duration": "5",
    "outputResolution": "720p"
  }
},
).json()["taskId"]

print(f"Task created: {task_id}")

# 2. Poll until complete
while True:
    data = requests.get(
        "https://kinovi.ai/api/v1/jobs/recordInfo",
        params={"taskId": task_id},
        headers=HEADERS,
    ).json()

    if data["status"] == "success":
        print("Done!", data["output"])
        break
    if data["status"] == "fail":
        raise SystemExit(f"Failed: {data['error']}")

    print(f"Status: {data['status']} — waiting...", end="\r")
    time.sleep(2)

1. Calling the API

Submit a generation request. The API returns a taskId that you use to poll for the result.

curl -X POST "https://kinovi.ai/api/v1/jobs/createTask" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $KINOVI_API_KEY" \
  -d '{
  "model": "happyhorse1.0",
  "inputs": {
    "prompt": "A young woman turns her head slowly toward camera, soft hair drift, warm golden-hour backlight, shallow depth of field",
    "resolution": "1280x720",
    "duration": "5",
    "outputResolution": "720p"
  }
}'

const response = await fetch("https://kinovi.ai/api/v1/jobs/createTask", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: `Bearer ${process.env.KINOVI_API_KEY}`,
  },
  body: JSON.stringify({
  "model": "happyhorse1.0",
  "inputs": {
    "prompt": "A young woman turns her head slowly toward camera, soft hair drift, warm golden-hour backlight, shallow depth of field",
    "resolution": "1280x720",
    "duration": "5",
    "outputResolution": "720p"
  }
}),
});

const { taskId } = await response.json();
console.log("Task created:", taskId);

import os
import requests

response = requests.post(
    "https://kinovi.ai/api/v1/jobs/createTask",
    headers={"Authorization": f"Bearer {os.environ['KINOVI_API_KEY']}"},
    json={
  "model": "happyhorse1.0",
  "inputs": {
    "prompt": "A young woman turns her head slowly toward camera, soft hair drift, warm golden-hour backlight, shallow depth of field",
    "resolution": "1280x720",
    "duration": "5",
    "outputResolution": "720p"
  }
},
)

task_id = response.json()["taskId"]
print("Task created:", task_id)

Response

{
  "taskId": "abc123-def456-..."
}

2. Authentication

Authenticate with a Bearer token in the Authorization header.

Get your API key

Environment variable

export KINOVI_API_KEY="your-api-key"

3. Getting Results

Poll the recordInfo endpoint until status is success or fail. Poll every 2 seconds.

GEThttps://kinovi.ai/api/v1/jobs/recordInfo?taskId={taskId}

# Poll until status is "success" or "fail"
curl -X GET "https://kinovi.ai/api/v1/jobs/recordInfo?taskId={taskId}" \
  -H "Authorization: Bearer $KINOVI_API_KEY"

async function pollResult(taskId) {
  while (true) {
    const res = await fetch(
      `https://kinovi.ai/api/v1/jobs/recordInfo?taskId=${taskId}`,
      { headers: { Authorization: `Bearer ${process.env.KINOVI_API_KEY}` } },
    );
    const data = await res.json();

    if (data.status === "success") return data.output;
    if (data.status === "fail") throw new Error(data.error?.message);

    await new Promise((r) => setTimeout(r, 2000)); // poll every 2s
  }
}

import time

def poll_result(task_id):
    while True:
        res = requests.get(
            "https://kinovi.ai/api/v1/jobs/recordInfo",
            params={"taskId": task_id},
            headers={"Authorization": f"Bearer {os.environ['KINOVI_API_KEY']}"},
        )
        data = res.json()

        if data["status"] == "success":
            return data["output"]
        if data["status"] == "fail":
            raise Exception(data["error"]["message"])

        time.sleep(2)  # poll every 2s

Status values

Status	Description
waiting	Task queued
generating	Processing in progress
success	Output ready
fail	Generation failed

Output

{
  "taskId": "abc123-def456-...",
  "model": "happyhorse1.0",
  "status": "success",
  "creditsUsed": 165,
  "output": [
    { "url": "https://cdn.kinovi.ai/...", "width": 1280, "height": 720 }
  ],
  "error": null,
  "createTime": 1714000000000,
  "completeTime": 1714000060000
}

4. Schema

Schema

Input parameters

Parameter	Type	Required	Default	Description
model	string	Yes	—	Model identifier. Use "happyhorse1.0".
inputs.prompt	string	No	—	Motion prompt. Be specific about actions ("slow head turn") rather than abstract qualities ("cinematic").
inputs.uploadedUrls	string[]	No	—	Array with one image URL for I2V. Omit for T2V. Max 1 image, ≤10MB, ≥300px, ratio 1:2.5–2.5:1.
inputs.resolution	string	No	"1280x720"	Aspect-ratio preset for T2V: "720x720" (1:1), "720x960" (3:4), "960x720" (4:3), "1280x720" (16:9), or "720x1280" (9:16). For I2V, the source image ratio usually defines the framing.
inputs.duration	string	No	"5"	Video duration in seconds as a string. Prefer "5"; "5s" is also accepted for compatibility. Supported range is "3" to "15". Cost = rate × seconds (e.g., 720p 5s = 140 credits).
inputs.outputResolution	string	No	"720p"	"720p" (28 cr/s) or "1080p" (50 cr/s). Start with 720p for iteration, use 1080p for final delivery.

Example requests

Text-to-Video

{
  "prompt": "A young woman turns her head slowly toward camera, soft hair drift, warm golden-hour backlight, shallow depth of field",
  "resolution": "1280x720",
  "duration": "5",
  "outputResolution": "720p"
}

Image-to-Video

{
  "prompt": "Animate with a gentle head turn, natural blinking, and subtle hair movement in soft wind",
  "uploadedUrls": ["https://example.com/portrait.jpg"],
  "resolution": "720x1280",
  "duration": "5",
  "outputResolution": "1080p"
}

Open HappyHorse Playground

README

HappyHorse 1.0 is now available on Kinovi.

Overview

Welcome to Happy Horse 1.0! This AI video model is your new go-to for turning text into high-quality, short video clips. It is absolutely perfect for whipping up quick visual concepts, mood-driven aesthetics, and simple scenes in no time.

Who Is This For

If you are a content creator (TikTok, Instagram, etc.), filmmaker, or digital artist, you are in the right place. It is the perfect tool for storyboarding, making catchy social media clips, or testing out fresh visual ideas without having to spend much credits compared to other video models.

How to use it and where to start

Let's look at a normal prompt and generation so you know what to do. This is just one example. Type this into the prompt box:

Prompt: The dragon and the raptor are fighting. The camera orbits behind them to see the dragon pick the raptor up and drop it into the surf. The raptor gets up, shakes itself off, and jumps to try to catch the dragon's legs in its jaws. Settings: 15 seconds, 720p and ratio of 16:9.

Note: 1080p will make the video larger in size and higher quality, but it will have a longer load time and cost more credits.

Keeping the focus on a single subject and a strong mood yields the absolute best and most consistent results. If you succeeded in this sample, the video should look like this:

You can also use the templates shown here in this showcase to experiment with the prompt, alter it to what you like as practice.

Strengths of Happy Horse

Happy Horse thrives on simplicity. It performs beautifully with clearly defined, low-complexity setups. When you need a crisp, beautiful visual draft right this second, its rapid generation speed and HD image quality make it a true powerhouse for ideation. You can even bring simple photos to life. It takes on average about 1-3 minutes to generate a 15 second video.

What not to do

The longer the word count is on the prompt, the more overwhelmed Happy Horse can get with generating the video. The model can become unstable with fast-paced action, sharp camera movements, intense physical movement, or multi-character interactions. If your scene requires flawless physics or exact directorial choreography, it might be better to use another video model for now.

It cannot handle long prompts as well without it not generating the video or worse, not following your instructions. The audio quality also leaves more to be desired. This issue also persists in drawn animation like anime and cartoons, but worse. So unless it's simple animation, I would recommend Seedance2.

"A demonstration of what a bad generation looks like. The word count was 1,500 and was supposd to be a raptor and dragon battling, similar to the previous video demonstrated."

Prompting Guidance

The golden rule is to keep your prompts short, clear, and focused. Tell the model exactly who is there, what they are doing, and what the vibe is. For example:

"An orange tabby cat sitting on a windowsill watching the rain, 1990s retro anime style."

Giving the model a clean subject and setting without overwhelming it with instructions is the secret to highly stable videos. Do not make it too short or it will be confused. Keep it around 500-1000 characters. If it is too long, it will not follow instructions as well.

Comparison to other models

When looking at the wider AI video landscape, Happy Horse establishes a very clear and practical niche. While advanced models like Seedance2 currently lead the pack when it comes to handling highly complex, multi-subject sequences, Happy Horse brings some serious competition to models like Kling. For rapid ideation, clean single-subject scenes, and fast iterations, it holds its own beautifully against Kling, offering a highly accessible and efficient alternative for your daily workflow.

Seedance2 video example:

Frequently Asked Questions

Why didn't the model follow my prompt exactly? For the highest accuracy, prompts need to be simply worded and kept under 500 characters. When prompts become too long or layered with multiple instructions, the model can easily get confused and start skipping details.

Why did my generation fail? Most of the time, a failed generation is just a temporary technical hiccup and does not mean you violated any guidelines. Simply try hitting generate again! Any credits used on a failed generation are automatically refunded to your account.

Why are there distortions or mutations in my video? As a version 1.0 release, Happy Horse is still in its early stages and will occasionally have some difficult moments, especially with complex motion. Following the best practices—keeping scenes simple and focusing on a single subject—will help significantly reduce the chances of visual distortion.

Community Feedback

We believe in building with our community, which means being transparent about where the model stands today. Here is what early users are saying about how Happy Horse 1.0 stacks up in the current AI landscape:

Horace Dodd "Seedance is a tool for professional output, while Happy Horse feels more like a tool for ideation. That said, Happy Horse costs about 25% less than Seedance, so if you're looking for a more budget-friendly option, I would definitely recommend it. "https://x.com/horacedodd/status/2048764107403526250 "

BaconYT "When I tried Happy Horse 1.0, the base quality is fine and the audio is okay, but physical combat and physics are very rough. I generated a video on the official website and it gave me a messy anime fight sequence. I don't think it is better than Seedance 2.0. Seedance is much better at adding extra details to make scenes feel complete, even when using its faster model." https://www.youtube.com/channel/UCzL6QjPTxU1Gz9UEVXqAQiQ

Jay Nwabueze "I tested Happy Horse 1.0. It is a good start, but not on the level of Seedance 2.0 or Kling 3 yet. Some of the physics feel off, and the visuals still have that oily, plastic AI look. Still a long way to go." https://www.instagram.com/jaynwabueze1

Pricing

Item	Details
720p base rate	28 credits / second
1080p base rate	50 credits / second
5s 720p example	140 credits total
5s 1080p example	250 credits total
10s 720p example	280 credits total
Duration range	3 to 15 seconds
vs Seedance Pro 720p	28 vs 40 cr/s (30% cheaper)
vs Kling 3.0 std	28 vs 50 cr/s (44% cheaper)

View full pricing & plans →