AI 能力 API 文档

输入提示词生成图片，可选择尺寸、比例和模型支持的高级图像参数。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "gpt-image-2",
  "prompt": "A clean product photo on a soft studio background.",
  "size": "1536x1024",
  "n": 1
}

response = requests.post(
    f"{BASE_URL}/v1/images/async/generations",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/images/async/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["data"]["status"]).lower()

    if status in ("success", "succeeded", "completed"):
        items = task.get("data", {}).get("data", {}).get("data", [])
        first = items[0] if items else {}
        result = first.get("url") or first.get("b64_json")
        if not result:
            raise RuntimeError(f"No image result in response: {task}")
        print(result)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入提示词生成图片，可选择尺寸、比例和模型支持的高级图像参数。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "gpt-image-2-pro",
  "prompt": "A clean product photo on a soft studio background.",
  "size": "1:1",
  "resolution": "1k",
  "n": 1
}

response = requests.post(
    f"{BASE_URL}/v1/images/async/generations",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/images/async/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["data"]["status"]).lower()

    if status in ("success", "succeeded", "completed"):
        items = task.get("data", {}).get("data", {}).get("data", [])
        first = items[0] if items else {}
        result = first.get("url") or first.get("b64_json")
        if not result:
            raise RuntimeError(f"No image result in response: {task}")
        print(result)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入提示词生成图片，可选择尺寸、比例和模型支持的高级图像参数。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "gpt-image-2-max",
  "prompt": "A clean product photo on a soft studio background.",
  "size": "1024x1024",
  "n": 1
}

response = requests.post(
    f"{BASE_URL}/v1/images/async/generations",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/images/async/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["data"]["status"]).lower()

    if status in ("success", "succeeded", "completed"):
        items = task.get("data", {}).get("data", {}).get("data", [])
        first = items[0] if items else {}
        result = first.get("url") or first.get("b64_json")
        if not result:
            raise RuntimeError(f"No image result in response: {task}")
        print(result)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入提示词生成图片，可选择尺寸、比例和模型支持的高级图像参数。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "gemini-3.1-flash-image",
  "prompt": "A clean product photo on a soft studio background.",
  "n": 1,
  "size": "1K",
  "aspect_ratio": "1:1"
}

response = requests.post(
    f"{BASE_URL}/v1/images/async/generations",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/images/async/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["data"]["status"]).lower()

    if status in ("success", "succeeded", "completed"):
        items = task.get("data", {}).get("data", {}).get("data", [])
        first = items[0] if items else {}
        result = first.get("url") or first.get("b64_json")
        if not result:
            raise RuntimeError(f"No image result in response: {task}")
        print(result)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入提示词生成图片，可选择尺寸、比例和模型支持的高级图像参数。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "gemini-3.0-pro-image",
  "prompt": "A clean product photo on a soft studio background.",
  "n": 1,
  "size": "1K",
  "aspect_ratio": "1:1"
}

response = requests.post(
    f"{BASE_URL}/v1/images/async/generations",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/images/async/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["data"]["status"]).lower()

    if status in ("success", "succeeded", "completed"):
        items = task.get("data", {}).get("data", {}).get("data", [])
        first = items[0] if items else {}
        result = first.get("url") or first.get("b64_json")
        if not result:
            raise RuntimeError(f"No image result in response: {task}")
        print(result)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入一张图片和编辑提示词生成新图，部分模型支持 mask 和输出格式控制。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
}


files = {
    "model": (None, "gpt-image-2"),
    "prompt": (None, "A clean product photo on a soft studio background."),
    "image": (None, "https://example.com/input.png"),
    "n": (None, "1"),
    "size": (None, "1536x1024"),
}

response = requests.post(
    f"{BASE_URL}/v1/images/async/edits",
    headers=headers,
    files=files,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/images/async/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["data"]["status"]).lower()

    if status in ("success", "succeeded", "completed"):
        items = task.get("data", {}).get("data", {}).get("data", [])
        first = items[0] if items else {}
        result = first.get("url") or first.get("b64_json")
        if not result:
            raise RuntimeError(f"No image result in response: {task}")
        print(result)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入一张图片和编辑提示词生成新图，部分模型支持 mask 和输出格式控制。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
}


files = {
    "model": (None, "gpt-image-2-max"),
    "prompt": (None, "A clean product photo on a soft studio background."),
    "image": (None, "https://example.com/input.png"),
    "n": (None, "1"),
    "size": (None, "1024x1024"),
}

response = requests.post(
    f"{BASE_URL}/v1/images/async/edits",
    headers=headers,
    files=files,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/images/async/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["data"]["status"]).lower()

    if status in ("success", "succeeded", "completed"):
        items = task.get("data", {}).get("data", {}).get("data", [])
        first = items[0] if items else {}
        result = first.get("url") or first.get("b64_json")
        if not result:
            raise RuntimeError(f"No image result in response: {task}")
        print(result)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入一张图片和编辑提示词生成新图，部分模型支持 mask 和输出格式控制。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
}


files = {
    "model": (None, "gemini-3.1-flash-image"),
    "prompt": (None, "A clean product photo on a soft studio background."),
    "image": (None, "https://example.com/input.png"),
    "n": (None, "1"),
    "size": (None, "1K"),
}

response = requests.post(
    f"{BASE_URL}/v1/images/async/edits",
    headers=headers,
    files=files,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/images/async/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["data"]["status"]).lower()

    if status in ("success", "succeeded", "completed"):
        items = task.get("data", {}).get("data", {}).get("data", [])
        first = items[0] if items else {}
        result = first.get("url") or first.get("b64_json")
        if not result:
            raise RuntimeError(f"No image result in response: {task}")
        print(result)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入一张图片和编辑提示词生成新图，部分模型支持 mask 和输出格式控制。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
}


files = {
    "model": (None, "gemini-3.0-pro-image"),
    "prompt": (None, "A clean product photo on a soft studio background."),
    "image": (None, "https://example.com/input.png"),
    "n": (None, "1"),
    "size": (None, "1K"),
}

response = requests.post(
    f"{BASE_URL}/v1/images/async/edits",
    headers=headers,
    files=files,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/images/async/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["data"]["status"]).lower()

    if status in ("success", "succeeded", "completed"):
        items = task.get("data", {}).get("data", {}).get("data", [])
        first = items[0] if items else {}
        result = first.get("url") or first.get("b64_json")
        if not result:
            raise RuntimeError(f"No image result in response: {task}")
        print(result)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入多张参考图和提示词生成新图，适合人物、产品、风格或构图参考。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "gpt-image-2",
  "prompt": "A clean product photo on a soft studio background.",
  "size": "1536x1024",
  "n": 1,
  "image_urls": [
    "https://example.com/ref-1.png",
    "https://example.com/ref-2.png"
  ]
}

response = requests.post(
    f"{BASE_URL}/v1/images/async/generations",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/images/async/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["data"]["status"]).lower()

    if status in ("success", "succeeded", "completed"):
        items = task.get("data", {}).get("data", {}).get("data", [])
        first = items[0] if items else {}
        result = first.get("url") or first.get("b64_json")
        if not result:
            raise RuntimeError(f"No image result in response: {task}")
        print(result)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入多张参考图和提示词生成新图，适合人物、产品、风格或构图参考。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "gpt-image-2-pro",
  "prompt": "A clean product photo on a soft studio background.",
  "size": "1:1",
  "resolution": "1k",
  "n": 1,
  "image_urls": [
    "https://example.com/ref-1.png",
    "https://example.com/ref-2.png"
  ]
}

response = requests.post(
    f"{BASE_URL}/v1/images/async/generations",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/images/async/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["data"]["status"]).lower()

    if status in ("success", "succeeded", "completed"):
        items = task.get("data", {}).get("data", {}).get("data", [])
        first = items[0] if items else {}
        result = first.get("url") or first.get("b64_json")
        if not result:
            raise RuntimeError(f"No image result in response: {task}")
        print(result)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入多张参考图和提示词生成新图，适合人物、产品、风格或构图参考。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "gpt-image-2-max",
  "prompt": "A clean product photo on a soft studio background.",
  "size": "1024x1024",
  "n": 1,
  "image_urls": [
    "https://example.com/ref-1.png",
    "https://example.com/ref-2.png"
  ]
}

response = requests.post(
    f"{BASE_URL}/v1/images/async/generations",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/images/async/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["data"]["status"]).lower()

    if status in ("success", "succeeded", "completed"):
        items = task.get("data", {}).get("data", {}).get("data", [])
        first = items[0] if items else {}
        result = first.get("url") or first.get("b64_json")
        if not result:
            raise RuntimeError(f"No image result in response: {task}")
        print(result)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入多张参考图和提示词生成新图，适合人物、产品、风格或构图参考。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "gemini-3.1-flash-image",
  "prompt": "A clean product photo on a soft studio background.",
  "n": 1,
  "size": "1K",
  "aspect_ratio": "1:1",
  "image_urls": [
    "https://example.com/ref-1.png",
    "https://example.com/ref-2.png"
  ]
}

response = requests.post(
    f"{BASE_URL}/v1/images/async/generations",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/images/async/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["data"]["status"]).lower()

    if status in ("success", "succeeded", "completed"):
        items = task.get("data", {}).get("data", {}).get("data", [])
        first = items[0] if items else {}
        result = first.get("url") or first.get("b64_json")
        if not result:
            raise RuntimeError(f"No image result in response: {task}")
        print(result)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入多张参考图和提示词生成新图，适合人物、产品、风格或构图参考。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "gemini-3.0-pro-image",
  "prompt": "A clean product photo on a soft studio background.",
  "n": 1,
  "size": "1K",
  "aspect_ratio": "1:1",
  "image_urls": [
    "https://example.com/ref-1.png",
    "https://example.com/ref-2.png"
  ]
}

response = requests.post(
    f"{BASE_URL}/v1/images/async/generations",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/images/async/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["data"]["status"]).lower()

    if status in ("success", "succeeded", "completed"):
        items = task.get("data", {}).get("data", {}).get("data", [])
        first = items[0] if items else {}
        result = first.get("url") or first.get("b64_json")
        if not result:
            raise RuntimeError(f"No image result in response: {task}")
        print(result)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入提示词生成视频，可选择比例、清晰度、时长和模型支持的视频控制参数。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "happyhorse-1.0-t2v",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "metadata": {
    "resolution": "1080P",
    "ratio": "16:9",
    "duration": 5
  }
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入提示词生成视频，可选择比例、清晰度、时长和模型支持的视频控制参数。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "wan2.7-t2v",
  "input": {
    "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
    "negative_prompt": "low quality, blurry"
  },
  "parameters": {
    "resolution": "720P",
    "ratio": "16:9",
    "duration": 5,
    "prompt_extend": False,
    "watermark": False
  }
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入提示词生成视频，可选择比例、清晰度、时长和模型支持的视频控制参数。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "video-fast-720p",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "aspect_ratio": "16:9",
  "duration": 6
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入提示词生成视频，可选择比例、清晰度、时长和模型支持的视频控制参数。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "video-pro-720p",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "aspect_ratio": "16:9",
  "duration": 6
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入提示词生成视频，可选择比例、清晰度、时长和模型支持的视频控制参数。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "grok-imagine-video",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion."
}

response = requests.post(
    f"{BASE_URL}/v1/videos/generations",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["output"]["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/grok/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["output"]["task_status"]).lower()

    if status in ("success", "succeeded", "completed"):
        output = task.get("output") or {}
        result_url = output.get("media_url") or output.get("video_url") or output.get("result_url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入提示词生成视频，可选择比例、清晰度、时长和模型支持的视频控制参数。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "omni_flash",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "aspect_ratio": "16:9",
  "resolution": "720p",
  "duration": 10
}

response = requests.post(
    f"{BASE_URL}/v1/videos/generations",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["output"]["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/notevideo/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["output"]["task_status"]).lower()

    if status in ("success", "succeeded", "completed"):
        output = task.get("output") or {}
        result_url = output.get("media_url") or output.get("video_url") or output.get("result_url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入提示词生成视频，可选择比例、清晰度、时长和模型支持的视频控制参数。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "omni_flash-fast",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "duration": 10,
  "seconds": "10",
  "aspect_ratio": "16:9",
  "resolution": "720p"
}

response = requests.post(
    f"{BASE_URL}/v1/videos/generations",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["output"]["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/notevideo/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["output"]["task_status"]).lower()

    if status in ("success", "succeeded", "completed"):
        output = task.get("output") or {}
        result_url = output.get("media_url") or output.get("video_url") or output.get("result_url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入提示词生成视频，可选择比例、清晰度、时长和模型支持的视频控制参数。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "kling-video",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "duration": 5,
  "aspect_ratio": "16:9",
  "resolution": "720p"
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入提示词生成视频，可选择比例、清晰度、时长和模型支持的视频控制参数。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "veo_3_1-fast",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion."
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入首帧图片和可选提示词生成视频，输出比例通常跟随图片或模型设置。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "happyhorse-1.0-i2v",
  "image": "https://example.com/first-frame.png",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "metadata": {
    "resolution": "1080P",
    "duration": 5
  }
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入首帧图片和可选提示词生成视频，输出比例通常跟随图片或模型设置。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "wan2.7-i2v",
  "input": {
    "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
    "media": [
      {
        "type": "first_frame",
        "url": "https://example.com/first-frame.png"
      }
    ]
  },
  "parameters": {
    "resolution": "720P",
    "prompt_extend": False,
    "watermark": False,
    "duration": 5
  }
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入首帧图片和可选提示词生成视频，输出比例通常跟随图片或模型设置。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "video-fast-720p",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "aspect_ratio": "16:9",
  "duration": 6,
  "image_url": "https://example.com/first-frame.png"
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入首帧图片和可选提示词生成视频，输出比例通常跟随图片或模型设置。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "video-pro-720p",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "aspect_ratio": "16:9",
  "duration": 6,
  "image_url": "https://example.com/first-frame.png"
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入首帧图片和可选提示词生成视频，输出比例通常跟随图片或模型设置。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "grok-imagine-video",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "image_url": "https://example.com/first-frame.png"
}

response = requests.post(
    f"{BASE_URL}/v1/videos/generations",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["output"]["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/grok/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["output"]["task_status"]).lower()

    if status in ("success", "succeeded", "completed"):
        output = task.get("output") or {}
        result_url = output.get("media_url") or output.get("video_url") or output.get("result_url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入首帧图片和可选提示词生成视频，输出比例通常跟随图片或模型设置。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "omni_flash_i2v",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "image_url": "https://example.com/first-frame.png",
  "aspect_ratio": "16:9",
  "resolution": "720p",
  "duration": 10
}

response = requests.post(
    f"{BASE_URL}/v1/videos/generations",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["output"]["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/notevideo/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["output"]["task_status"]).lower()

    if status in ("success", "succeeded", "completed"):
        output = task.get("output") or {}
        result_url = output.get("media_url") or output.get("video_url") or output.get("result_url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入首帧图片和可选提示词生成视频，输出比例通常跟随图片或模型设置。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "omni_flash-fast",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "image_url": "https://example.com/first-frame.png",
  "duration": 10,
  "seconds": "10",
  "aspect_ratio": "16:9",
  "resolution": "720p"
}

response = requests.post(
    f"{BASE_URL}/v1/videos/generations",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["output"]["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/notevideo/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["output"]["task_status"]).lower()

    if status in ("success", "succeeded", "completed"):
        output = task.get("output") or {}
        result_url = output.get("media_url") or output.get("video_url") or output.get("result_url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入首帧图片和可选提示词生成视频，输出比例通常跟随图片或模型设置。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "kling-video",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "duration": 5,
  "aspect_ratio": "16:9",
  "resolution": "720p",
  "images": [
    "https://example.com/first-frame.png"
  ]
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入首帧图片和可选提示词生成视频，输出比例通常跟随图片或模型设置。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "veo_3_1-fast",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "image_url": "https://example.com/first-frame.png"
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入首帧和尾帧两张图，模型在两张边界帧之间生成视频。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "wan2.7-i2v",
  "input": {
    "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
    "media": [
      {
        "type": "first_frame",
        "url": "https://example.com/first-frame.png"
      },
      {
        "type": "last_frame",
        "url": "https://example.com/last-frame.png"
      }
    ]
  },
  "parameters": {
    "resolution": "720P",
    "prompt_extend": False,
    "watermark": False,
    "duration": 5
  }
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入首帧和尾帧两张图，模型在两张边界帧之间生成视频。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "veo_3_1-fast",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "images": [
    "https://example.com/first-frame.png",
    "https://example.com/last-frame.png"
  ],
  "duration": 8
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入源视频和提示词，从源视频结尾继续生成后续画面，可选尾帧参考图。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "wan2.7-i2v",
  "input": {
    "prompt": "Continue the clip with the subject walking out of the room, natural handheld camera, no subtitles.",
    "media": [
      {
        "type": "first_clip",
        "url": "https://example.com/source.mp4"
      },
      {
        "type": "last_frame",
        "url": "https://example.com/last-frame.png"
      }
    ]
  },
  "parameters": {
    "resolution": "720P",
    "prompt_extend": False,
    "watermark": False,
    "duration": 5
  }
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入多张参考图和提示词生成视频，适合人物、产品、场景参考。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "happyhorse-1.0-r2v",
  "images": [
    "https://example.com/ref-1.png",
    "https://example.com/ref-2.png"
  ],
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "metadata": {
    "resolution": "1080P",
    "ratio": "16:9",
    "duration": 5
  }
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入多张参考图和提示词生成视频，适合人物、产品、场景参考。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "wan2.7-r2v",
  "input": {
    "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
    "media": [
      {
        "type": "reference_image",
        "url": "https://example.com/ref-1.png"
      },
      {
        "type": "reference_image",
        "url": "https://example.com/ref-2.png"
      }
    ]
  },
  "parameters": {
    "resolution": "720P",
    "prompt_extend": False,
    "watermark": False,
    "duration": 5,
    "ratio": "16:9"
  }
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入多张参考图和提示词生成视频，适合人物、产品、场景参考。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "video-fast-720p",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "aspect_ratio": "16:9",
  "duration": 6,
  "image_url": "https://example.com/ref-1.png",
  "extra_images": [
    "https://example.com/ref-2.png"
  ]
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入多张参考图和提示词生成视频，适合人物、产品、场景参考。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "video-pro-720p",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "aspect_ratio": "16:9",
  "duration": 6,
  "image_url": "https://example.com/ref-1.png",
  "extra_images": [
    "https://example.com/ref-2.png"
  ]
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入多张参考图和提示词生成视频，适合人物、产品、场景参考。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "grok-imagine-video",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "images": [
    "https://example.com/ref-1.png",
    "https://example.com/ref-2.png",
    "https://example.com/ref-3.png"
  ]
}

response = requests.post(
    f"{BASE_URL}/v1/videos/generations",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["output"]["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/grok/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["output"]["task_status"]).lower()

    if status in ("success", "succeeded", "completed"):
        output = task.get("output") or {}
        result_url = output.get("media_url") or output.get("video_url") or output.get("result_url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入多张参考图和提示词生成视频，适合人物、产品、场景参考。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "omni_flash_components",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "reference_image_urls": [
    "https://example.com/ref-1.png",
    "https://example.com/ref-2.png"
  ],
  "aspect_ratio": "16:9",
  "resolution": "720p",
  "duration": 10
}

response = requests.post(
    f"{BASE_URL}/v1/videos/generations",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["output"]["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/notevideo/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["output"]["task_status"]).lower()

    if status in ("success", "succeeded", "completed"):
        output = task.get("output") or {}
        result_url = output.get("media_url") or output.get("video_url") or output.get("result_url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入多张参考图和提示词生成视频，适合人物、产品、场景参考。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "omni_flash-fast",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "reference_image_urls": [
    "https://example.com/ref-1.png",
    "https://example.com/ref-2.png"
  ],
  "duration": 10,
  "seconds": "10",
  "aspect_ratio": "16:9",
  "resolution": "720p"
}

response = requests.post(
    f"{BASE_URL}/v1/videos/generations",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["output"]["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/notevideo/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["output"]["task_status"]).lower()

    if status in ("success", "succeeded", "completed"):
        output = task.get("output") or {}
        result_url = output.get("media_url") or output.get("video_url") or output.get("result_url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入多张参考图和提示词生成视频，适合人物、产品、场景参考。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "kling-video",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "duration": 5,
  "aspect_ratio": "16:9",
  "resolution": "720p",
  "images": [
    "https://example.com/ref-1.png",
    "https://example.com/ref-2.png"
  ]
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入参考图和音频生成视频，适合需要音频驱动画面的场景。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "video-fast-720p",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "aspect_ratio": "16:9",
  "duration": 6,
  "image_url": "https://example.com/ref-1.png",
  "extra_audios": [
    "https://example.com/audio.mp3"
  ]
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入参考图和音频生成视频，适合需要音频驱动画面的场景。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "video-pro-720p",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "aspect_ratio": "16:9",
  "duration": 6,
  "image_url": "https://example.com/ref-1.png",
  "extra_audios": [
    "https://example.com/audio.mp3"
  ]
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入参考图、参考视频和音频生成视频，适合复杂多模态控制。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "wan2.7-r2v",
  "input": {
    "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
    "media": [
      {
        "type": "first_frame",
        "url": "https://example.com/first-frame.png"
      },
      {
        "type": "reference_video",
        "url": "https://example.com/ref-video.mp4",
        "reference_voice": "https://example.com/voice.mp3"
      },
      {
        "type": "reference_image",
        "url": "https://example.com/ref-1.png"
      }
    ]
  },
  "parameters": {
    "resolution": "720P",
    "prompt_extend": False,
    "watermark": False,
    "duration": 5,
    "ratio": "16:9"
  }
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入参考图、参考视频和音频生成视频，适合复杂多模态控制。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "video-fast-720p",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "aspect_ratio": "16:9",
  "duration": 6,
  "image_url": "https://example.com/ref-1.png",
  "extra_audios": [
    "https://example.com/audio.mp3"
  ],
  "extra_videos": [
    "https://example.com/ref-video.mp4"
  ]
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入参考图、参考视频和音频生成视频，适合复杂多模态控制。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "video-pro-720p",
  "prompt": "A natural 5-second homestay vlog shot, handheld phone camera, warm daylight, realistic motion.",
  "aspect_ratio": "16:9",
  "duration": 6,
  "image_url": "https://example.com/ref-1.png",
  "extra_audios": [
    "https://example.com/audio.mp3"
  ],
  "extra_videos": [
    "https://example.com/ref-video.mp4"
  ]
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入源视频 URL 和提示词生成复刻或改写视频，可选参考图。网页本地上传会先转成公网 URL 再提交。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "omni_flash_edit",
  "input_video": "https://example.com/source.mp4",
  "messages": [
    {
      "role": "user",
      "content": "Recreate this clip in a warmer, more cinematic travel vlog style."
    }
  ],
  "resolution": "720p",
  "resolution_name": "720p"
}

response = requests.post(
    f"{BASE_URL}/v1/videos/generations",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["output"]["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/notevideo/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["output"]["task_status"]).lower()

    if status in ("success", "succeeded", "completed"):
        output = task.get("output") or {}
        result_url = output.get("media_url") or output.get("video_url") or output.get("result_url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入源视频 URL 和提示词生成复刻或改写视频，可选参考图。网页本地上传会先转成公网 URL 再提交。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "omni_flash_edit-fast",
  "prompt": "Recreate this clip in a warmer, more cinematic travel vlog style.",
  "video_url": "https://example.com/source.mp4",
  "input_video": "https://example.com/source.mp4",
  "resolution": "720p"
}

response = requests.post(
    f"{BASE_URL}/v1/videos/generations",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = data["output"]["task_id"]

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/notevideo/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str(task["output"]["task_status"]).lower()

    if status in ("success", "succeeded", "completed"):
        output = task.get("output") or {}
        result_url = output.get("media_url") or output.get("video_url") or output.get("result_url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入源视频 URL 和提示词生成复刻或改写视频，可选参考图。网页本地上传会先转成公网 URL 再提交。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "wan2.7-videoedit",
  "input": {
    "prompt": "Recreate this clip in a warmer, more cinematic travel vlog style.",
    "media": [
      {
        "type": "video",
        "url": "https://example.com/source.mp4"
      },
      {
        "type": "reference_image",
        "url": "https://example.com/ref-1.png"
      }
    ]
  },
  "parameters": {
    "resolution": "720P",
    "prompt_extend": False,
    "watermark": False,
    "ratio": "16:9",
    "audio_setting": "auto"
  }
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)

输入源视频 URL 和提示词生成复刻或改写视频，可选参考图。网页本地上传会先转成公网 URL 再提交。

import os
import time
import requests

BASE_URL = os.getenv("HAPPYHORSE_BASE_URL", "{{BASE_URL}}")
API_KEY = os.getenv("HAPPYHORSE_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing HAPPYHORSE_API_KEY")

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

json_data = {
  "model": "happyhorse-1.0-video-edit",
  "prompt": "Recreate this clip in a warmer, more cinematic travel vlog style.",
  "images": [
    "https://example.com/ref-1.png"
  ],
  "metadata": {
    "video": "https://example.com/source.mp4",
    "resolution": "1080P",
    "duration": 5,
    "audio_setting": "auto"
  }
}

response = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=headers,
    json=json_data,
    timeout=60,
)
response.raise_for_status()
data = response.json()

task_id = (data.get("id") or data.get("task_id") or data.get("output", {}).get("task_id"))

while True:
    response = requests.get(
        f"{BASE_URL}/v1/videos/{task_id}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()
    status = str((task.get("status") or task.get("output", {}).get("task_status"))).lower()

    if status in ("success", "succeeded", "completed"):
        metadata = task.get("metadata") or {}
        results = task.get("results") or []
        result_url = (
            task.get("video_url")
            or task.get("media_url")
            or task.get("result_url")
            or metadata.get("url")
        )
        if not result_url and results:
            result_url = results[0].get("url")
        if not result_url:
            raise RuntimeError(f"No video result URL in response: {task}")
        print(result_url)
        break
    if status in ("failed", "failure", "error"):
        raise RuntimeError(task)

    time.sleep(5)