Geração de Vídeo Wan2.6

curl --request POST \
  --url https://api.apimart.ai/v1/videos/generations \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "wan2.6",
    "prompt": "A cute cat running on the grass",
    "aspect_ratio": "16:9",
    "resolution": "720p",
    "duration": 5
  }'

import requests

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

payload = {
    "model": "wan2.6",
    "prompt": "A cute cat running on the grass",
    "aspect_ratio": "16:9",
    "resolution": "720p",
    "duration": 5
}

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: "wan2.6",
  prompt: "A cute cat running on the grass",
  aspect_ratio: "16:9",
  resolution: "720p",
  duration: 5
};

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":        "wan2.6",
        "prompt":       "A cute cat running on the grass",
        "aspect_ratio": "16:9",
        "resolution":   "720p",
        "duration":     5,
    }

    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": "wan2.6",
          "prompt": "A cute cat running on the grass",
          "aspect_ratio": "16:9",
          "resolution": "720p",
          "duration": 5
        }
        """;

        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" => "wan2.6",
    "prompt" => "A cute cat running on the grass",
    "aspect_ratio" => "16:9",
    "resolution" => "720p",
    "duration" => 5
];

$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: "wan2.6",
  prompt: "A cute cat running on the grass",
  aspect_ratio: "16:9",
  resolution: "720p",
  duration: 5
}

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": "wan2.6",
    "prompt": "A cute cat running on the grass",
    "aspect_ratio": "16:9",
    "resolution": "720p",
    "duration": 5
]

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"": ""wan2.6"",
            ""prompt"": ""A cute cat running on the grass"",
            ""aspect_ratio"": ""16:9"",
            ""resolution"": ""720p"",
            ""duration"": 5
        }";

        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"
  }
}

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": "wan2.6",
    "prompt": "A cute cat running on the grass",
    "aspect_ratio": "16:9",
    "resolution": "720p",
    "duration": 5
  }'

import requests

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

payload = {
    "model": "wan2.6",
    "prompt": "A cute cat running on the grass",
    "aspect_ratio": "16:9",
    "resolution": "720p",
    "duration": 5
}

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: "wan2.6",
  prompt: "A cute cat running on the grass",
  aspect_ratio: "16:9",
  resolution: "720p",
  duration: 5
};

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":        "wan2.6",
        "prompt":       "A cute cat running on the grass",
        "aspect_ratio": "16:9",
        "resolution":   "720p",
        "duration":     5,
    }

    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": "wan2.6",
          "prompt": "A cute cat running on the grass",
          "aspect_ratio": "16:9",
          "resolution": "720p",
          "duration": 5
        }
        """;

        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" => "wan2.6",
    "prompt" => "A cute cat running on the grass",
    "aspect_ratio" => "16:9",
    "resolution" => "720p",
    "duration" => 5
];

$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: "wan2.6",
  prompt: "A cute cat running on the grass",
  aspect_ratio: "16:9",
  resolution: "720p",
  duration: 5
}

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": "wan2.6",
    "prompt": "A cute cat running on the grass",
    "aspect_ratio": "16:9",
    "resolution": "720p",
    "duration": 5
]

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"": ""wan2.6"",
            ""prompt"": ""A cute cat running on the grass"",
            ""aspect_ratio"": ""16:9"",
            ""resolution"": ""720p"",
            ""duration"": 5
        }";

        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": "wan2.6",
    "prompt": "A cute cat running on the grass",
    "aspect_ratio": "16:9",
    "resolution": "720p",
    "duration": 5
  }'

import requests

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

payload = {
    "model": "wan2.6",
    "prompt": "A cute cat running on the grass",
    "aspect_ratio": "16:9",
    "resolution": "720p",
    "duration": 5
}

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: "wan2.6",
  prompt: "A cute cat running on the grass",
  aspect_ratio: "16:9",
  resolution: "720p",
  duration: 5
};

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":        "wan2.6",
        "prompt":       "A cute cat running on the grass",
        "aspect_ratio": "16:9",
        "resolution":   "720p",
        "duration":     5,
    }

    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": "wan2.6",
          "prompt": "A cute cat running on the grass",
          "aspect_ratio": "16:9",
          "resolution": "720p",
          "duration": 5
        }
        """;

        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" => "wan2.6",
    "prompt" => "A cute cat running on the grass",
    "aspect_ratio" => "16:9",
    "resolution" => "720p",
    "duration" => 5
];

$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: "wan2.6",
  prompt: "A cute cat running on the grass",
  aspect_ratio: "16:9",
  resolution: "720p",
  duration: 5
}

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": "wan2.6",
    "prompt": "A cute cat running on the grass",
    "aspect_ratio": "16:9",
    "resolution": "720p",
    "duration": 5
]

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"": ""wan2.6"",
            ""prompt"": ""A cute cat running on the grass"",
            ""aspect_ratio"": ""16:9"",
            ""resolution"": ""720p"",
            ""duration"": 5
        }";

        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

Parâmetros da requisição

string

obrigatório

Nome do modelo de geração de vídeo, fixo como wan2.6

boolean

padrão:"false"

Define se o conteúdo deve ser moderado antes do envio da tarefa de vídeo.

true: verificar prompts e imagens de entrada com omni-moderation-latest
false ou omitido: não enviar solicitação de moderação, sem custo nem latência adicionais de moderação (padrão)

string

obrigatório

Descrição do conteúdo do vídeoObrigatório para o modo text-to-video. Descreva cenas, ações e estilos em detalhes para obter melhores resultadosExemplo: "A cute cat stretching in the sunlight"

array<url>

Array de URLs de imagens de referência (apenas 1 imagem suportada)Obrigatório para o modo image-to-video. Suporta URLs de imagens publicamente acessíveisExemplo: ["https://example.com/image.jpg"]

O sistema seleciona automaticamente o modo text-to-video ou image-to-video com base na presença de image_urls

string

Prompt negativo que descreve conteúdo indesejadoExemplo: "blurry, low quality, distorted"

string

padrão:"16:9"

Proporção do vídeoOpções:

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

Padrão: 16:9

Não suportado no modo image-to-video

string

padrão:"720p"

Resolução do vídeoOpções:

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

Padrão: 720p

Resolução 480p não é suportada

Cobrado por segundo. O preço varia por resolução. Consulte o catálogo de modelos para preços específicos

integer

padrão:"5"

Duração do vídeo (segundos)Valores suportados: apenas 5, 10, 15 segundosPadrão: 5

integer

Seed aleatório para resultados reproduzíveisExemplo: 12345

boolean

Se deve estender automaticamente o promptQuando ativado, o sistema otimizará e enriquecerá automaticamente seu prompt

boolean

Se deve adicionar áudio automaticamenteQuando ativado, o sistema gerará áudio correspondente para o vídeo

string

URL de áudio especificadoTem prioridade sobre o parâmetro audio

A duração do áudio não pode exceder a duração do vídeo. Se o áudio for mais curto que a duração do vídeo, a primeira parte do vídeo terá som enquanto o restante será silencioso.

string

Tipo de tomadaOpções:

single - Tomada única
multi - Múltiplas tomadas

boolean

Se deve adicionar marca d’água

string

Nome do template de efeito para o modo de efeitos especiais image-to-video

Ao usar o modo de efeitos:

Apenas uma imagem é necessária (passada via image_urls)
Nenhum prompt é necessário (o modelo ignora o campo prompt)

Efeitos gerais:

squish - Esmagar
rotation - Rotação
poke - Cutucar
inflate - Inflar balão
dissolve - Dissolver molecular
melt - Derreter por onda de calor
icecream - Planeta de sorvete
flying - Levitação mágica

Efeitos de pessoa única:

carousel - Carrossel do tempo
singleheart - Te amo
dance1 - Momento de balanço
dance2 - Movimento de dança

Para mais efeitos, consulte a Documentação de templates do Alibaba Wanxiang

Combinações de resolução e proporção

Proporção	Descrição	Tamanho 720p	Tamanho 1080p
`16:9`	Paisagem (padrão)	1280×720	1920×1080
`9:16`	Retrato	720×1280	1080×1920
`1:1`	Quadrado	960×960	1440×1440
`4:3`	Paisagem	1088×832	1632×1248
`3:4`	Retrato	832×1088	1248×1632

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 (Requisição simples)

{
  "model": "wan2.6",
  "prompt": "A cute cat stretching in the sunlight"
}

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

{
  "model": "wan2.6",
  "prompt": "A cute cat running on the grass",
  "negative_prompt": "blurry, low quality, distorted",
  "aspect_ratio": "16:9",
  "resolution": "720p",
  "duration": 5,
  "seed": 12345,
  "prompt_extend": true,
  "audio": true,
  "shot_type": "single",
  "watermark": false
}

Caso 3: Imagem para vídeo

{
  "model": "wan2.6",
  "prompt": "A kitten running on the ground",
  "image_urls": ["https://upload.apimart.ai/f/apimart-models-images/9998233432754770-c059992d-9b01-47d5-810d-ea0502ac9279-image_task_01KD7SSXDBCEWZ869D6PF249ZW_0.png"],
  "resolution": "1080p",
  "duration": 10
}

Caso 4: Imagem para vídeo (Imagem Base64)

{
  "model": "wan2.6",
  "prompt": "Make the cat stand up and walk",
  "image_urls": ["data:image/png;base64,iVBORw0KGgo..."],
  "duration": 5
}

Descrição dos modos

Texto para vídeo (Text-to-Video)

O parâmetro prompt é obrigatório
O parâmetro image_urls não é necessário

Imagem para vídeo (Image-to-Video)

O parâmetro image_urls é obrigatório (apenas 1 imagem suportada)
O parâmetro prompt é opcional, usado para descrever as ações esperadas

O sistema seleciona automaticamente o modo com base na presença de image_urls na requisição

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

Modelos

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 Wan2.6

Autorização

Parâmetros da requisição

Combinações de resolução e proporção

Resposta

Casos de uso

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

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

Caso 3: Imagem para vídeo

Caso 4: Imagem para vídeo (Imagem Base64)

Descrição dos modos

Texto para vídeo (Text-to-Video)

Imagem para vídeo (Image-to-Video)

​Autorização

​Parâmetros da requisição

​Combinações de resolução e proporção

​Resposta

​Casos de uso

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

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

​Caso 3: Imagem para vídeo

​Caso 4: Imagem para vídeo (Imagem Base64)

​Descrição dos modos

​Texto para vídeo (Text-to-Video)

​Imagem para vídeo (Image-to-Video)

Autorização

Parâmetros da requisição

Combinações de resolução e proporção

Resposta

Casos de uso

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

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

Caso 3: Imagem para vídeo

Caso 4: Imagem para vídeo (Imagem Base64)

Descrição dos modos

Texto para vídeo (Text-to-Video)

Imagem para vídeo (Image-to-Video)