Happy Horse 1.1 API Guide
Most developer docs for Happy Horse 1.1 assume you live in JavaScript. This guide does not. Below is a Python-and-curl walkthrough of the Happy Horse 1.1 image-to-video endpoint on Muapi, with the full input schema, real error handling, honest answers on the open-source question, and pricing you can actually plan a budget around. If you are evaluating alternatives, the Seedance 2.5 API guide covers the closest competing model.
What Is Happy Horse 1.1?
Happy Horse 1.1 is a video generation model from Alibaba's ATH AI Innovation Unit (the team formerly known as the Taotian Future Life Lab, led by ex-Kuaishou VP Zhang Di). The model launched anonymously and was later attributed to Alibaba via CNBC reporting. It is built on a 15-billion-parameter unified Transformer architecture with native audio-video synchronization and multilingual lip-sync, which is the headline differentiator: audio and motion are generated jointly rather than stitched together afterward.
It reached #1 on the Artificial Analysis Video Arena leaderboard, surpassing Sora, Veo, and ByteDance Seedance 2.0 (see our Seedance 2.0 vs Kling 3.0 breakdown for context on where the competition stands). The model ships as a four-endpoint family: image-to-video, reference-to-video, text-to-video, and video-edit. This guide focuses on the image-to-video endpoint, which animates a single still image into 1080p video with synced audio and lip-sync.
Setting Up: Authentication and the Muapi Client
Grab an API key from your Muapi dashboard, then export it so it never lands in source control:
export MUAPI_KEY="your_api_key_here"
All requests authenticate with a Bearer token in the Authorization header and hit https://muapi.ai/api. For Python you only need requests:
pip install requests
No SDK is required. The endpoint is a plain async REST queue, which is exactly why the curl path below works just as well.
The Image-to-Video Input Schema, Parameter by Parameter
| Parameter | Type | Required | Default | Notes |
|---|---|---|---|---|
images_list | string[] | Yes | — | Single-element array — one JPEG/PNG/WEBP URL. Image must be ≥400px on shortest side, ≤10 MB |
prompt | string | No | "" | Motion/camera guidance |
aspect_ratio | enum | No | 16:9 | 16:9, 9:16, 1:1, 4:3, 3:4 |
duration | integer | No | 5 | 3–15 seconds |
The only hard requirement is images_list. It is an array even though it accepts exactly one image — pass a one-element list, not a bare string.
Submitting a Request: Python and curl
The flow is: POST to the endpoint, receive a request_id, then poll the result endpoint until status is completed. The output returns a video file object with url, content_type, file_name, file_size, width, height, fps, duration, and num_frames, plus the seed that was actually used.
import os, time, requests
API_KEY = os.environ["MUAPI_KEY"]
BASE = "https://muapi.ai/api"
HEADERS = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}
def submit_i2v():
payload = {
"images_list": ["https://example.com/portrait.jpg"],
"prompt": "The camera slowly pushes in as she turns her head and smiles, soft wind moves her hair",
"aspect_ratio": "16:9",
"duration": 5,
}
r = requests.post(
f"{BASE}/v1/happy-horse-1.1-image-to-video",
headers=HEADERS, json=payload, timeout=30,
)
r.raise_for_status()
return r.json()["request_id"]
def poll(request_id, timeout_s=600, interval=5):
deadline = time.time() + timeout_s
while time.time() < deadline:
r = requests.get(
f"{BASE}/v1/predictions/{request_id}/result",
headers=HEADERS, timeout=30,
)
r.raise_for_status()
data = r.json()
status = data.get("status")
if status == "completed":
return data["output"]
if status in ("failed", "error"):
raise RuntimeError(f"Job failed: {data.get('error', 'unknown error')}")
time.sleep(interval)
raise TimeoutError(f"Job {request_id} did not finish in {timeout_s}s")
if __name__ == "__main__":
rid = submit_i2v()
out = poll(rid)
video = out["video"]
print("URL: ", video["url"])
print("Size: ", video["width"], "x", video["height"])
print("FPS: ", video["fps"])
print("Duration: ", video["duration"], "s")
print("Frames: ", video["num_frames"])
print("Seed used:", out["seed"])
The equivalent for non-SDK developers in raw curl:
# 1. Submit
REQ=$(curl -s -X POST https://muapi.ai/api/v1/happy-horse-1.1-image-to-video-1080p \
-H "Authorization: Bearer $MUAPI_KEY" \
-H "Content-Type: application/json" \
-d '{
"images_list": ["https://example.com/portrait.jpg"],
"prompt": "The camera slowly pushes in as she turns and smiles",
"aspect_ratio": "16:9",
"duration": 5
}' | grep -o '"request_id":"[^"]*"' | cut -d'"' -f4)
# 2. Poll until completed
curl -s https://muapi.ai/api/v1/predictions/$REQ/result \
-H "Authorization: Bearer $MUAPI_KEY"
If you would rather not poll, supply a webhook URL in your submission and Muapi will POST the completed result to your callback endpoint instead.
Error Handling and Production Patterns
The polling loop above already covers the two things most JS quickstarts skip: explicit failed/error handling and a wall-clock timeout so a stuck job cannot hang your worker forever. For production, layer on a few more habits:
- Pre-validate the image. Check that your image is ≥400px on the shortest side and ≤10 MB before submitting. Fail fast rather than waiting for the queue to reject it.
- Retry transient failures only. Wrap submission in an exponential-backoff retry for 429/5xx responses; never auto-retry a
failedjob with the same bad input. - Pin the seed for reproducibility. Pass a fixed
seed(0 to 2147483647) when you need deterministic output for A/B comparisons or regression tests. The used seed comes back in the output so you can reproduce any clip later. - Parallelize at volume. Each request is independent, so for batch workloads fire submissions concurrently and collect
request_ids, then poll them as a pool rather than serially.
Prompt Engineering for Image-to-Video
In image-to-video the picture already defines the scene, so do not waste your 2500 characters re-describing what is visible. Spend them on motion and camera: "slow dolly-in," "subject turns toward camera," "leaves drift left to right," "handheld micro-shake." Because Happy Horse 1.1 generates synchronized audio with multilingual lip-sync, you can also prompt spoken dialogue or ambient audio cues, and the model will animate the mouth to match. Keep prompts tight and ordered from subject motion to camera motion to atmosphere.
Is Happy Horse Open Source? Clearing Up the Confusion
Despite widespread "fully open source" claims, no weights have been published. The official GitHub and Hugging Face pages show "coming soon," which means the model is currently closed-source and API-only. If self-hosting is a hard requirement, Happy Horse 1.1 does not meet it today.
Be careful where you click. There are unaffiliated happyhorse.* clone domains and a fake brooks376/Happy-Horse-1.0 GitHub repo circulating; none are official and none ship real weights. Treat only first-party Alibaba channels and the Muapi listing as authoritative, and rely solely on the Muapi pricing page for cost numbers.
Pricing and Cost Planning
Cost scales with duration and resolution. On Muapi, all Happy Horse 1.1 modes are billed per second of output video:
- 1080p: $0.18 per second
- 720p: $0.14 per second
So a default 5-second 1080p clip costs $0.90, and the same clip at 720p is $0.70. A 15-second 1080p clip is $2.70. Estimate per-clip cost as rate × duration, and prototype at 720p before committing to 1080p for final renders — you get the same model and motion quality at half the price. You can try it hands-on in the Happy Horse 1.1 playground before spending a cent. See the Muapi plans page for current rates and plan limits.
FAQ
Is Happy Horse 1.1 open source and can I download the weights for self-hosting?
No. Despite "fully open source" marketing, no weights have been released. The official GitHub and Hugging Face pages say "coming soon," so the model is currently closed-source and API-only. Avoid unaffiliated clone domains and the fake brooks376/Happy-Horse-1.0 repo, which do not contain real weights.
Which Happy Horse endpoints exist and how do I access them via API?
There are four: image-to-video, reference-to-video, text-to-video, and video-edit. All are reached over Muapi's async REST queue at https://muapi.ai/api using a Bearer token. Submit with a POST, then poll GET /v1/predictions/{request_id}/result or use a webhook callback.
How is Happy Horse 1.1 pricing calculated for different durations and resolutions? Pricing is per second of output. On Muapi, 1080p is $0.18/second and 720p is $0.14/second, so cost equals rate × duration. A 5-second 1080p clip is $0.90; a 5-second 720p clip is $0.70. Confirm live rates on the Muapi plans page.
