curl --request POST \
  --url https://api.apimart.ai/v1/videos/generations \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "happyhorse-1.1",
    "prompt": "A little girl walking down the road, cinematic feel",
    "resolution": "1080P",
    "size": "16:9",
    "duration": 5,
    "seed": 42
  }'

import requests

url = "https://api.apimart.ai/v1/videos/generations"

payload = {
    "model": "happyhorse-1.1",
    "prompt": "A little girl walking down the road, cinematic feel",
    "resolution": "1080P",
    "size": "16:9",
    "duration": 5,
    "seed": 42
}

headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

const url = "https://api.apimart.ai/v1/videos/generations";

const payload = {
  model: "happyhorse-1.1",
  prompt: "A little girl walking down the road, cinematic feel",
  resolution: "1080P",
  size: "16:9",
  duration: 5,
  seed: 42
};

const headers = {
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
};

fetch(url, {
  method: "POST",
  headers: headers,
  body: JSON.stringify(payload)
})
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    url := "https://api.apimart.ai/v1/videos/generations"

    payload := map[string]interface{}{
        "model":      "happyhorse-1.1",
        "prompt":     "A little girl walking down the road, cinematic feel",
        "resolution": "1080P",
        "size":       "16:9",
        "duration":   5,
        "seed":       42,
    }

    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer <token>")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class Main {
    public static void main(String[] args) throws Exception {
        String url = "https://api.apimart.ai/v1/videos/generations";

        String payload = """
        {
          "model": "happyhorse-1.1",
          "prompt": "A little girl walking down the road, cinematic feel",
          "resolution": "1080P",
          "size": "16:9",
          "duration": 5,
          "seed": 42
        }
        """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer <token>")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

<?php

$url = "https://api.apimart.ai/v1/videos/generations";

$payload = [
    "model" => "happyhorse-1.1",
    "prompt" => "A little girl walking down the road, cinematic feel",
    "resolution" => "1080P",
    "size" => "16:9",
    "duration" => 5,
    "seed" => 42
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer <token>",
    "Content-Type: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

require 'net/http'
require 'json'
require 'uri'

url = URI("https://api.apimart.ai/v1/videos/generations")

payload = {
  model: "happyhorse-1.1",
  prompt: "A little girl walking down the road, cinematic feel",
  resolution: "1080P",
  size: "16:9",
  duration: 5,
  seed: 42
}

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json

response = http.request(request)
puts response.body

import Foundation

let url = URL(string: "https://api.apimart.ai/v1/videos/generations")!

let payload: [String: Any] = [
    "model": "happyhorse-1.1",
    "prompt": "A little girl walking down the road, cinematic feel",
    "resolution": "1080P",
    "size": "16:9",
    "duration": 5,
    "seed": 42
]

var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }

    if let data = data, let responseString = String(data: data, encoding: .utf8) {
        print(responseString)
    }
}

task.resume()

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var url = "https://api.apimart.ai/v1/videos/generations";

        var payload = @"{
            ""model"": ""happyhorse-1.1"",
            ""prompt"": ""A little girl walking down the road, cinematic feel"",
            ""resolution"": ""1080P"",
            ""size"": ""16:9"",
            ""duration"": 5,
            ""seed"": 42
        }";

        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");

        var content = new StringContent(payload, Encoding.UTF8, "application/json");
        var response = await client.PostAsync(url, content);
        var result = await response.Content.ReadAsStringAsync();

        Console.WriteLine(result);
    }
}

{
  "code": 200,
  "data": [
    {
      "status": "submitted",
      "task_id": "task_01J9HA7JPQ9A0Z6JZ3V8M9W6PZ"
    }
  ]
}

{
  "error": {
    "code": 400,
    "message": "Invalid request parameters",
    "type": "invalid_request_error"
  }
}

{
  "error": {
    "code": 401,
    "message": "Invalid authentication credentials",
    "type": "authentication_error"
  }
}

{
  "error": {
    "code": 402,
    "message": "Insufficient balance. Please top up your account",
    "type": "payment_required"
  }
}

{
  "error": {
    "code": 429,
    "message": "Rate limit exceeded. Please try again later",
    "type": "rate_limit_error"
  }
}

{
  "error": {
    "code": 500,
    "message": "Internal server error. Please try again later",
    "type": "server_error"
  }
}

HappyHorse

Geração de Vídeo HappyHorse 1.1

Modelo de geração de vídeo HappyHorse 1.1 do Alibaba Cloud Bailian (entrada unificada, roteamento automático de modelo único)
Roteamento automático por parâmetros: T2V (apenas prompt) / I2V (first_frame_image) / R2V (image_urls)
Suporta resoluções 720P/1080P e qualquer duração inteira de 3 a 15 segundos
Cobrado apenas por resolução × duração (segundos), independentemente da capacidade

POST

videos

generations

curl --request POST \
  --url https://api.apimart.ai/v1/videos/generations \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "happyhorse-1.1",
    "prompt": "A little girl walking down the road, cinematic feel",
    "resolution": "1080P",
    "size": "16:9",
    "duration": 5,
    "seed": 42
  }'

import requests

url = "https://api.apimart.ai/v1/videos/generations"

payload = {
    "model": "happyhorse-1.1",
    "prompt": "A little girl walking down the road, cinematic feel",
    "resolution": "1080P",
    "size": "16:9",
    "duration": 5,
    "seed": 42
}

headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

const url = "https://api.apimart.ai/v1/videos/generations";

const payload = {
  model: "happyhorse-1.1",
  prompt: "A little girl walking down the road, cinematic feel",
  resolution: "1080P",
  size: "16:9",
  duration: 5,
  seed: 42
};

const headers = {
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
};

fetch(url, {
  method: "POST",
  headers: headers,
  body: JSON.stringify(payload)
})
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    url := "https://api.apimart.ai/v1/videos/generations"

    payload := map[string]interface{}{
        "model":      "happyhorse-1.1",
        "prompt":     "A little girl walking down the road, cinematic feel",
        "resolution": "1080P",
        "size":       "16:9",
        "duration":   5,
        "seed":       42,
    }

    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer <token>")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class Main {
    public static void main(String[] args) throws Exception {
        String url = "https://api.apimart.ai/v1/videos/generations";

        String payload = """
        {
          "model": "happyhorse-1.1",
          "prompt": "A little girl walking down the road, cinematic feel",
          "resolution": "1080P",
          "size": "16:9",
          "duration": 5,
          "seed": 42
        }
        """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer <token>")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

<?php

$url = "https://api.apimart.ai/v1/videos/generations";

$payload = [
    "model" => "happyhorse-1.1",
    "prompt" => "A little girl walking down the road, cinematic feel",
    "resolution" => "1080P",
    "size" => "16:9",
    "duration" => 5,
    "seed" => 42
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer <token>",
    "Content-Type: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

require 'net/http'
require 'json'
require 'uri'

url = URI("https://api.apimart.ai/v1/videos/generations")

payload = {
  model: "happyhorse-1.1",
  prompt: "A little girl walking down the road, cinematic feel",
  resolution: "1080P",
  size: "16:9",
  duration: 5,
  seed: 42
}

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json

response = http.request(request)
puts response.body

import Foundation

let url = URL(string: "https://api.apimart.ai/v1/videos/generations")!

let payload: [String: Any] = [
    "model": "happyhorse-1.1",
    "prompt": "A little girl walking down the road, cinematic feel",
    "resolution": "1080P",
    "size": "16:9",
    "duration": 5,
    "seed": 42
]

var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }

    if let data = data, let responseString = String(data: data, encoding: .utf8) {
        print(responseString)
    }
}

task.resume()

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var url = "https://api.apimart.ai/v1/videos/generations";

        var payload = @"{
            ""model"": ""happyhorse-1.1"",
            ""prompt"": ""A little girl walking down the road, cinematic feel"",
            ""resolution"": ""1080P"",
            ""size"": ""16:9"",
            ""duration"": 5,
            ""seed"": 42
        }";

        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");

        var content = new StringContent(payload, Encoding.UTF8, "application/json");
        var response = await client.PostAsync(url, content);
        var result = await response.Content.ReadAsStringAsync();

        Console.WriteLine(result);
    }
}

{
  "code": 200,
  "data": [
    {
      "status": "submitted",
      "task_id": "task_01J9HA7JPQ9A0Z6JZ3V8M9W6PZ"
    }
  ]
}

{
  "error": {
    "code": 400,
    "message": "Invalid request parameters",
    "type": "invalid_request_error"
  }
}

{
  "error": {
    "code": 401,
    "message": "Invalid authentication credentials",
    "type": "authentication_error"
  }
}

{
  "error": {
    "code": 402,
    "message": "Insufficient balance. Please top up your account",
    "type": "payment_required"
  }
}

{
  "error": {
    "code": 429,
    "message": "Rate limit exceeded. Please try again later",
    "type": "rate_limit_error"
  }
}

{
  "error": {
    "code": 500,
    "message": "Internal server error. Please try again later",
    "type": "server_error"
  }
}

curl --request POST \
  --url https://api.apimart.ai/v1/videos/generations \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "happyhorse-1.1",
    "prompt": "A little girl walking down the road, cinematic feel",
    "resolution": "1080P",
    "size": "16:9",
    "duration": 5,
    "seed": 42
  }'

import requests

url = "https://api.apimart.ai/v1/videos/generations"

payload = {
    "model": "happyhorse-1.1",
    "prompt": "A little girl walking down the road, cinematic feel",
    "resolution": "1080P",
    "size": "16:9",
    "duration": 5,
    "seed": 42
}

headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

const url = "https://api.apimart.ai/v1/videos/generations";

const payload = {
  model: "happyhorse-1.1",
  prompt: "A little girl walking down the road, cinematic feel",
  resolution: "1080P",
  size: "16:9",
  duration: 5,
  seed: 42
};

const headers = {
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
};

fetch(url, {
  method: "POST",
  headers: headers,
  body: JSON.stringify(payload)
})
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    url := "https://api.apimart.ai/v1/videos/generations"

    payload := map[string]interface{}{
        "model":      "happyhorse-1.1",
        "prompt":     "A little girl walking down the road, cinematic feel",
        "resolution": "1080P",
        "size":       "16:9",
        "duration":   5,
        "seed":       42,
    }

    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer <token>")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class Main {
    public static void main(String[] args) throws Exception {
        String url = "https://api.apimart.ai/v1/videos/generations";

        String payload = """
        {
          "model": "happyhorse-1.1",
          "prompt": "A little girl walking down the road, cinematic feel",
          "resolution": "1080P",
          "size": "16:9",
          "duration": 5,
          "seed": 42
        }
        """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer <token>")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

<?php

$url = "https://api.apimart.ai/v1/videos/generations";

$payload = [
    "model" => "happyhorse-1.1",
    "prompt" => "A little girl walking down the road, cinematic feel",
    "resolution" => "1080P",
    "size" => "16:9",
    "duration" => 5,
    "seed" => 42
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer <token>",
    "Content-Type: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

require 'net/http'
require 'json'
require 'uri'

url = URI("https://api.apimart.ai/v1/videos/generations")

payload = {
  model: "happyhorse-1.1",
  prompt: "A little girl walking down the road, cinematic feel",
  resolution: "1080P",
  size: "16:9",
  duration: 5,
  seed: 42
}

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer <token>"
request["Content-Type"] = "application/json"
request.body = payload.to_json

response = http.request(request)
puts response.body

import Foundation

let url = URL(string: "https://api.apimart.ai/v1/videos/generations")!

let payload: [String: Any] = [
    "model": "happyhorse-1.1",
    "prompt": "A little girl walking down the road, cinematic feel",
    "resolution": "1080P",
    "size": "16:9",
    "duration": 5,
    "seed": 42
]

var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }

    if let data = data, let responseString = String(data: data, encoding: .utf8) {
        print(responseString)
    }
}

task.resume()

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var url = "https://api.apimart.ai/v1/videos/generations";

        var payload = @"{
            ""model"": ""happyhorse-1.1"",
            ""prompt"": ""A little girl walking down the road, cinematic feel"",
            ""resolution"": ""1080P"",
            ""size"": ""16:9"",
            ""duration"": 5,
            ""seed"": 42
        }";

        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");

        var content = new StringContent(payload, Encoding.UTF8, "application/json");
        var response = await client.PostAsync(url, content);
        var result = await response.Content.ReadAsStringAsync();

        Console.WriteLine(result);
    }
}

{
  "code": 200,
  "data": [
    {
      "status": "submitted",
      "task_id": "task_01J9HA7JPQ9A0Z6JZ3V8M9W6PZ"
    }
  ]
}

{
  "error": {
    "code": 400,
    "message": "Invalid request parameters",
    "type": "invalid_request_error"
  }
}

{
  "error": {
    "code": 401,
    "message": "Invalid authentication credentials",
    "type": "authentication_error"
  }
}

{
  "error": {
    "code": 402,
    "message": "Insufficient balance. Please top up your account",
    "type": "payment_required"
  }
}

{
  "error": {
    "code": 429,
    "message": "Rate limit exceeded. Please try again later",
    "type": "rate_limit_error"
  }
}

{
  "error": {
    "code": 500,
    "message": "Internal server error. Please try again later",
    "type": "server_error"
  }
}

Autorização

string

obrigatório

Todos os endpoints da API exigem autenticação via Bearer TokenObtenha sua chave de API:Acesse a página de gerenciamento de chaves de API para obter sua chave de APIAdicione ao cabeçalho da requisição:

Authorization: Bearer YOUR_API_KEY

Roteamento de modos

happyhorse-1.1 é a entrada unificada para Text-to-Video / Image-to-Video / Reference-Image-to-Video. O backend determina automaticamente o modo com base nos parâmetros recebidos. Todos os modos são cobrados pela mesma regra (apenas resolução × segundos):

Campos passados	Roteia para	Descrição do modo
Apenas `prompt`	Text-to-Video (T2V)	Gera vídeo puramente a partir de texto
`prompt` + `first_frame_image`	Image-to-Video (I2V)	Anima a partir de uma imagem do primeiro quadro
`prompt` + `image_urls` (1–9 imagens)	Reference-Image-to-Video (R2V)	Gera uma nova cena a partir de imagens de referência

Prioridade de roteamento (alta para baixa): first_frame_image > image_urls > apenas prompt. Regras de exclusão mútua: os dois campos de mídia (first_frame_image / image_urls) são mutuamente exclusivos. Passar dois campos mutuamente exclusivos ao mesmo tempo retorna 400 mixed_media_not_allowed.

Parâmetros da requisição

string

obrigatório

Nome do modelo de geração de vídeo, fixo como happyhorse-1.1

string

Descrição do conteúdo do vídeo, até 2500 caracteres; não pode conter tokens especiaisExemplo: "A little girl walking down the road, cinematic feel"

string

Imagem do primeiro quadro, aciona o I2V (Image-to-Video). Suporta URL ou base64 (data:image/<mime>;base64,<payload>, o gateway faz upload para o OSS automaticamente)Mutuamente exclusivo com image_urls

Requisitos da imagem do primeiro quadro:

Formato: JPEG / JPG / PNG / BMP / WEBP
Lado curto: ≥ 300px
Proporção: 1:2.5 a 2.5:1
Tamanho do arquivo: ≤ 10MB

array<string>

Array de imagens (Modo R2V): 1–9 imagens, usadas como referências de sujeito/estilo para gerar uma nova cenaSuporta URL ou base64Mutuamente exclusivo com first_frame_image

Requisitos da imagem de referência:

Formato: JPEG / JPG / PNG / BMP / WEBP
Lado curto: ≥ 720p recomendado
Proporção: curto / longo ≥ 0,4
Tamanho do arquivo: ≤ 10MB
Quantidade: 1–9 imagens

string

padrão:"1080P"

Resolução do vídeo (afeta a cobrança)Opções:

720P - Padrão
1080P - Alta definição (padrão)

integer

padrão:"5"

Duração do vídeo em segundos (afeta a cobrança)Intervalo suportado: qualquer inteiro de 3 a 15Padrão: 5

string

padrão:"16:9"

Proporção de telaFormatos suportados:

16:9 - Paisagem widescreen (padrão)
9:16 - Retrato
1:1 - Quadrado
4:3 - Paisagem
3:4 - Retrato

Ignorado no modo I2V — a proporção de saída é determinada automaticamente pela mídia de entrada (imagem do primeiro quadro)

boolean

padrão:"false"

Se deve adicionar uma marca d’água ao vídeo gerado

true: adiciona marca d’água
false: sem marca d’água (padrão)

integer

Seed aleatório usado para controlar a aleatoriedade do conteúdo geradoIntervalo de valores: [0, 2147483647]. Se omitido, um seed aleatório é usado.

Para requisições idênticas, o modelo gera resultados diferentes ao receber valores de seed diferentes (por exemplo, omitindo o seed)
Para requisições idênticas, o modelo gera resultados semelhantes ao receber o mesmo valor de seed, mas a consistência exata não é garantida

Resposta

integer

Código de status da resposta, 200 em caso de sucesso

array

Array de dados da resposta

Mostrar Elementos do array

string

Status da tarefa, submitted no envio inicial

string

Identificador único da tarefa para consultar o status e os resultados

Casos de uso

Caso 1: Texto para vídeo T2V (Requisição mais simples)

{
  "model": "happyhorse-1.1",
  "prompt": "A little girl walking down the road, cinematic feel"
}

Caso 2: Texto para vídeo T2V (Parâmetros completos)

{
  "model": "happyhorse-1.1",
  "prompt": "A coastal road at sunset, slow-motion camera push-in, cinematic feel",
  "resolution": "1080P",
  "size": "16:9",
  "duration": 8,
  "seed": 42
}

Caso 3: Imagem para vídeo I2V (first_frame_image)

{
  "model": "happyhorse-1.1",
  "prompt": "Bring the scene in the image to life",
  "first_frame_image": "https://example.com/first_frame.png",
  "resolution": "1080P",
  "duration": 5
}

Caso 4: Referência-Imagem para vídeo R2V (múltiplas referências)

{
  "model": "happyhorse-1.1",
  "prompt": "The protagonist from image 1 runs through the scene from image 2, then picks up the prop from image 3. Keep a 3D cartoon style with smooth motion.",
  "image_urls": [
    "https://example.com/img_01.jpg",
    "https://example.com/img_02.png",
    "https://example.com/img_03.jpeg"
  ],
  "resolution": "1080P",
  "size": "16:9",
  "duration": 5
}

Caso 5: 720P para economizar custo

{
  "model": "happyhorse-1.1",
  "prompt": "Waves crashing on the beach at sunset",
  "resolution": "720P",
  "size": "16:9",
  "duration": 5
}

Guia de seleção de modo

Requisito	Abordagem recomendada
Gerar vídeo apenas a partir de texto	Passe apenas `prompt` (T2V)
Fazer uma imagem “ganhar vida” (usar como primeiro quadro)	Passe `first_frame_image` (I2V)
Gerar uma nova cena a partir de um conjunto de imagens de referência	Passe `image_urls` (1–9, R2V)
Economizar custo	Use `resolution: "720P"`

Dicas de uso

Lógica de entrada unificada: os campos de entrada decidem o modo. Note que os dois campos de mídia (first_frame_image / image_urls) são mutuamente exclusivos
size efetivo apenas em T2V/R2V: no modo I2V, size é ignorado — a proporção de saída é determinada pela mídia de entrada
Duração: 5–10 segundos é o ponto ideal. Muito curto causa movimento truncado; muito longo aumenta significativamente o tempo de processamento upstream
Qualidade da imagem do primeiro quadro: clara, bem composta, sujeito centralizado — melhora significativamente a saída I2V
Escrita do prompt: descreva movimento / câmera / atmosfera (por exemplo, “slow push-in, cinematic, warm tones”) para obter melhores resultados do que descrições puramente estáticas de cena

Consultar resultados da tarefaA geração de vídeos é uma tarefa assíncrona que retorna um task_id no envio. Use o endpoint Obter status da tarefa para consultar o progresso e os resultados da geração.

Visão Geral

Série de Texto

Série de Imagem

Série de Vídeo

Série de Áudio

Série de Moderação

Gerenciamento de Upload

Gerenciamento de Tarefas

Gerenciamento de Conta

Geração de Vídeo HappyHorse 1.1

Autorização

Roteamento de modos

Parâmetros da requisição

Resposta

Casos de uso

Caso 1: Texto para vídeo T2V (Requisição mais simples)

Caso 2: Texto para vídeo T2V (Parâmetros completos)

Caso 3: Imagem para vídeo I2V (first_frame_image)

Caso 4: Referência-Imagem para vídeo R2V (múltiplas referências)

Caso 5: 720P para economizar custo

Guia de seleção de modo

Dicas de uso

​Autorização

​Roteamento de modos

​Parâmetros da requisição

​Resposta

​Casos de uso

​Caso 1: Texto para vídeo T2V (Requisição mais simples)

​Caso 2: Texto para vídeo T2V (Parâmetros completos)

​Caso 3: Imagem para vídeo I2V (first_frame_image)

​Caso 4: Referência-Imagem para vídeo R2V (múltiplas referências)

​Caso 5: 720P para economizar custo

​Guia de seleção de modo

​Dicas de uso

Autorização

Roteamento de modos

Parâmetros da requisição

Resposta

Casos de uso

Caso 1: Texto para vídeo T2V (Requisição mais simples)

Caso 2: Texto para vídeo T2V (Parâmetros completos)

Caso 3: Imagem para vídeo I2V (first_frame_image)

Caso 4: Referência-Imagem para vídeo R2V (múltiplas referências)

Caso 5: 720P para economizar custo

Guia de seleção de modo

Dicas de uso