Orux AI / Notas sobre modelos
Seedance 2.0 API: preços, limites e exemplos de vídeo
Compare Seedance 2.0, Mini, Fast e2.5 por segundo e vídeo: preços oficiais e fal, código Python, vídeos reais e limites de áudio, resolução e duração.

Neste artigo
Quanto custa a API do Seedance 2.0
Na Orux AI, o Seedance 2.0 custa 61.5 Credits ($0.3075) por segundo em 720p: um vídeo de 5 segundos sai por 307.5 Credits ($1.54). O Seedance 2.0 Mini começa em 12.59 Credits ($0.063) por segundo em 480p; o Seedance 2.5 chega a 237 Credits ($1.185) por segundo em 1080p. Na Orux, o preço depende apenas do modelo, resolução e duração; ligar o áudio não altera o custo.
Comparamos os quatro modelos por segundo e por vídeo aos preços oficiais e de terceiros verificáveis, deixando claro onde a Orux cobra mais. Um script Python cobre texto para vídeo e imagem para vídeo a partir do primeiro quadro. Os preços da Orux são de 29 de outubro de 2026; novas verificações de fontes primárias aparecem com a própria data.
Preço por segundo dos quatro modelos
A Orux cobra Credits por segundo de vídeo gerado; 1 Credit=$0.005.
| Modelo (Credits/s) | 480p | 720p | 1080p | 4K |
|---|---|---|---|---|
| Seedance 2.0 Mini | 12.59 ($0.063) | 28.32 ($0.142) | — | — |
| Seedance 2.0 Fast | 20.25 ($0.101) | 45.55 ($0.228) | — | — |
| Seedance 2.0 | 28.5 ($0.1425) | 61.5 ($0.3075) | 153 ($0.765) | 312 ($1.56) |
| Seedance 2.5 | 42 ($0.21) | 94.5 ($0.4725) | 237 ($1.185) | — |
Deslize para os lados para ver toda a tabela.
Subir de 720p para 1080p multiplica o preço por cerca de 2.5 tanto no 2.0 quanto no 2.5. Apenas o 2.0 oferece 4K na Orux, por cerca de cinco vezes sua tarifa 720p. Os totais abaixo usam as tarifas sem arredondamento: multiplicar somente as duas casas exibidas de Mini/Fast pode resultar em pequena diferença.
Custo de vídeos de 5 e 10 segundos
Para planejar por vídeo, multiplicamos as mesmas tarifas pela duração:
| Modelo e resolução | Vídeo de 5 s | Vídeo de 10 s |
|---|---|---|
| Mini 480p | 62.93 Credits ($0.31) | 125.86 Credits ($0.63) |
| Mini 720p | 141.59 Credits ($0.71) | 283.18 Credits ($1.42) |
| Fast 480p | 101.23 Credits ($0.51) | 202.47 Credits ($1.01) |
| Fast 720p | 227.77 Credits ($1.14) | 455.55 Credits ($2.28) |
| 2.0 480p | 142.5 Credits ($0.71) | 285 Credits ($1.43) |
| 2.0 720p | 307.5 Credits ($1.54) | 615 Credits ($3.08) |
| 2.0 1080p | 765 Credits ($3.83) | 1,530 Credits ($7.65) |
| 2.0 4K | 1,560 Credits ($7.80) | 3,120 Credits ($15.60) |
| 2.5 480p | 210 Credits ($1.05) | 420 Credits ($2.10) |
| 2.5 720p | 472.5 Credits ($2.36) | 945 Credits ($4.73) |
| 2.5 1080p | 1,185 Credits ($5.93) | 2,370 Credits ($11.85) |
Deslize para os lados para ver toda a tabela.
Um vídeo único de 30 segundos só é possível no 2.5; em 720p, custa 2,835 Credits ($14.18). Como referência, oKling 4.0 em 720p custa 42.75 Credits/s na Orux, entre Mini e Fast.
Preços oficiais e de terceiros
A ByteDance vende Seedance na China pelo Volcengine Ark, em CNY. Não convertemos para USD porque câmbio e condições da conta variam. Os exemplos oficiais de 5 segundos, 16:9 e sem entrada de vídeo eram estes na consulta original e na revisão de 1º de novembro de 2026:
| Modelo | 720p, 5 s | 1080p, 5 s |
|---|---|---|
| Seedance 2.0 | ~¥4.97 | ~¥12.39 |
| Seedance 2.0 Fast | ~¥4.00 | — |
| Seedance 2.0 Mini | ~¥2.48 | — |
| Seedance 2.5 | ~¥7.56 | ~¥18.71 |
Deslize para os lados para ver toda a tabela.
A oferta oficial cobra por tokens de vídeo; o valor por vídeo muda com resolução, proporção e duração. Tokens são unidades de medição, não segundos. A fórmula atual estima (duração da entrada+duração da saída)×largura da saída×altura da saída×fps÷ 1024. Multiplique pelo preço por token correspondente; o consumo exato é o usage.completion_tokens retornado. Confira a página oficial atual antes de orçar.
A plataforma de inferência fal publicou estes valores por segundo em um comparativo de agosto de 2026. A tabela mantém essa referência histórica:
| Modelo e resolução | Orux AI | fal (agosto 2026) | Diferença |
|---|---|---|---|
| Seedance 2.0, 720p | $0.3075/s | $0.3034/s | Orux cerca de 1% mais cara |
| Seedance 2.0, 1080p | $0.765/s | $0.682/s | Orux cerca de 12% mais cara |
| Seedance 2.0 Fast, 720p | $0.2278/s | $0.2419/s | Orux cerca de 6% mais barata |
| Seedance 2.5, 720p | $0.4725/s | ~$0.473/s | quase igual |
Deslize para os lados para ver toda a tabela.
A Orux não é mais barata em tudo. 720p fica praticamente empatado, Fast sai um pouco mais barato na Orux, mas 2.0 em 1080p custa mais. O artigo da fal data as tarifas em 10 de agosto de 2026 e seus valores por segundo não coincidem exatamente com a própria fórmula de tokens. Em 1º de novembro, o endpoint 2.0 da fal ainda mostrava $0.3034/$0.682 por segundo, enquanto o endpoint 2.5 também listava 1080p por aproximadamente $1.164/s, ausente no comparativo antigo. Pela fórmula, 1280 × 720, 24 fps e 5 segundos dão 108,000 tokens de vídeo: $1.512 no 2.0 a $0.014 por mil tokens, ou $2.3112 no 2.5 a $0.0214. Não são valores idênticos às aproximações por segundo e não devem ser tratados como preço fixo intercambiável.
A Orux oferece operação unificada: mesma chave e saldo para Seedance, Kling, Wan, imagem e chat, uma interface de envio e consulta e nenhuma cobrança por tarefas com falha ou expiradas.
Qual modelo usar em cada trabalho
| Trabalho | Modelo sugerido | Motivo |
|---|---|---|
| Exploração de prompts e storyboards | Mini 480p | 62.93 Credits por teste de 5 s |
| Vídeos sociais econômicos | Mini 720p | Menos da metade do 2.0 em 720p |
| 720p quando Mini não basta | Fast 720p, depois 2.0 720p | Subir uma etapa por vez |
| Cena principal 1080p de até 15 s | 2.0 1080p | Mais barato entre as duas opções 1080p |
| Entrega 4K | 2.0 4K | Única opção 4K |
| Tomada única maior que 15 s | 2.5 | Único com 4–30 s |
| Muitas referências: até 30 imagens ou 10 áudios | 2.5 | Limites de referência maiores |
Deslize para os lados para ver toda a tabela.
A tabela compara preço e limites, sem classificar qualidade. Não realizamos comparação controlada de qualidade. Teste primeiro a opção barata e avance apenas se o resultado não servir. Um teste de 5 segundos no Mini 480p custa menos de um quarto do mesmo vídeo no 2.0 em 720p.
Python: texto para vídeo e primeiro quadro
A geração na Orux é assíncrona: POST /api/v1/tasks retorna HTTP 202 e task_id; depois, consulte GET /api/v1/tasks/{task_id} até SUCCESS, FAILED ou EXPIRED. Somente SUCCESS é cobrado. A interface verificada usa consultas de status, sem opção de callback.
import os, time, json, requests
BASE = "https://orux.top/api/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['ORUX_API_KEY']}"}
# Credits per second on Orux AI, checked 2026-10-29
PER_SECOND = {
"seedance-2.0-mini": {"480p": 12.586, "720p": 28.318},
"seedance-2.0-fast": {"480p": 20.2468, "720p": 45.5548},
"seedance-2.0": {"480p": 28.5, "720p": 61.5, "1080p": 153, "4k": 312},
"seedance-2.5": {"480p": 42, "720p": 94.5, "1080p": 237},
}
def estimate(model: str, resolution: str, duration: int) -> float:
return round(PER_SECOND[model][resolution] * duration, 6)
def submit(model: str, payload: dict) -> str:
r = requests.post(f"{BASE}/tasks", headers=HEADERS,
json={"model": model, "input": payload}, timeout=60)
if r.status_code == 402:
raise RuntimeError("Insufficient balance: top up (not an auth error)")
r.raise_for_status()
task_id = r.json()["task_id"]
with open("video_tasks.jsonl", "a") as f: # persist before polling
f.write(json.dumps({"task_id": task_id, "model": model}) + "\n")
return task_id
def wait_and_save(task_id: str, path: str, max_wait: int = 1800) -> None:
deadline = time.time() + max_wait
while time.time() < deadline:
time.sleep(10) # videos take minutes; poll gently
t = requests.get(f"{BASE}/tasks/{task_id}", headers=HEADERS, timeout=30).json()
if t["status"] == "SUCCESS":
with open(path, "wb") as f:
f.write(requests.get(t["result"][0], timeout=300).content)
print("saved", path, "| link valid for", t.get("result_expires_in"))
return
if t["status"] in ("FAILED", "EXPIRED"):
raise RuntimeError(t.get("error") or t["status"]) # not charged
raise TimeoutError(f"{task_id} still running; resume polling, do not resubmit")
# 1) Text-to-video: cheap draft on Mini
draft = {
"prompt": "A slow cinematic camera push towards a ceramic mug on a wooden desk "
"in soft morning light. No people, no text.",
"resolution": "480p",
"duration": 5,
"aspect_ratio": "16:9",
"generate_audio": False,
}
print("estimate:", estimate("seedance-2.0-mini", "480p", 5), "Credits")
wait_and_save(submit("seedance-2.0-mini", draft), "draft.mp4")
# 2) Image-to-video: animate from a first frame on Seedance 2.0 at 720p
i2v = {
"prompt": "The steam rises and drifts left; the camera slowly orbits the mug.",
"first_frame_url": "https://example.com/mug-first-frame.jpg",
"resolution": "720p",
"duration": 5,
"aspect_ratio": "adaptive",
}
print("estimate:", estimate("seedance-2.0", "720p", 5), "Credits")
wait_and_save(submit("seedance-2.0", i2v), "final.mp4")Ao usar em um sistema real:
- Salve
task_idantes das consultas, como no script. Se o processo parar, retome o mesmo ID; reenviar gera e cobra outro vídeo. - As URLs são temporárias. A resposta inclui
result_expires_in; baixe e armazene o arquivo assim que a tarefa terminar com sucesso. 402indica saldo insuficiente, não chave errada. Direcione para alerta de recarga, não de autenticação.- Em
429, use espera exponencial com jitter. O exemplo original não implementa integralmente essa estratégia de repetição. - O 4K no 2.0 usa minúsculas:
resolution="4k".
Áudio, proporções e limites de duração
Valores aceitos nos formulários da Orux:
| Parâmetro | 2.0 Mini | 2.0 Fast | 2.0 | 2.5 |
|---|---|---|---|---|
resolution | 480p, 720p | 480p, 720p | 480p, 720p, 1080p, 4k | 480p, 720p, 1080p |
duration (segundos) | 4–15 | 4–15 | 4–15 | 4–30 |
aspect_ratio | 16:9, 9:16, 1:1, 4:3, 3:4, 21:9, adaptive | igual | igual | igual; padrão adaptive |
first_frame_url / last_frame_url | sim | sim | sim | sim |
reference_image_urls | até 9 | até 9 | até 9 | até 30 |
reference_audio_urls | até 3 | até 3 | até 3 | até 10 |
generate_audio | ligado por padrão | ligado por padrão | ligado por padrão | ligado por padrão |
| Opções extras | — | — | — | output_format: mp4 / mov, return_last_frame, draft |
Deslize para os lados para ver toda a tabela.
Todos os modelos vêm com áudio ativado. Os preços publicados da Orux variam somente por modelo, resolução e duração, então vídeo com áudio custa o mesmo que silencioso. Use "generate_audio": false se vai adicionar sua própria trilha e quer evitar som indesejado.
Só o 2.5 oferece return_last_frame: passe o último quadro retornado como first_frame_url do próximo vídeo. Para encadear nos modelos mais baratos, extraia o quadro final do arquivo baixado por conta própria; não presuma a mesma opção de retorno. Isso cria sequências maiores que 15 segundos com vários vídeos, sem ampliar o limite de uma geração única.
Um prompt nos quatro modelos
As páginas compartilham o exemplo existente “Morning light”, gerado com mesmo prompt e configurações: 4 segundos, 480p, 16:9, áudio desligado. Os arquivos salvos têm 4.04 segundos; 2.0, Fast e Mini medem 864 × 496, e 2.5 mede 854 × 480. Veja duas saídas:
Para os 4 segundos solicitados, Mini custa 50.34 Credits, Fast 80.99, 2.0 custa 114 e 2.5 custa 168. Não substitua a duração solicitada pelos 4.04 segundos do arquivo ao calcular esse orçamento. Compare lado a lado nas páginas e decida se a diferença importa para sua tarefa; isso ajuda mais que alegações genéricas sobre as versões.
Para custos incluindo Kling, Wan e Vidu, veja o comparativo de APIs de vídeo econômicas (em inglês). Para parâmetros e preços de Kling, veja o guia da API Kling 4.0 (em inglês).
FAQ
Quanto custa o Seedance 2.0 por segundo?
Na consulta de 29 de outubro de 2026, a Orux cobra 28.5 Credits ($0.1425) em 480p, 61.5 ($0.3075) em 720p, 153 ($0.765) em 1080p e 312 ($1.56) em 4K por segundo. 5 segundos em 720p custam 307.5 Credits ($1.54).
Qual a diferença entre Mini e Fast?
Na Orux, ambos aceitam 480p/720p, 4–15 segundos e as mesmas entradas. Mini custa 12.59 Credits/s em 480p, contra 20.25 do Fast, cerca de 62% do preço. Não medimos diferença de qualidade ou velocidade; teste seus próprios prompts.
O Seedance 2.5 está disponível por API?
Sim: seedance-2.5 usa a mesma API de tarefas por 42, 94.5 e 237 Credits/s em 480p, 720p e 1080p. Entre estes quatro modelos, só ele aceita até 30 segundos por vídeo e 30 imagens de referência.
Áudio tem custo extra?
Não. Na Orux o preço depende de modelo, resolução e duração; generate_audio vem ativado. Com ou sem áudio, o valor é igual. O artigo da fal de agosto de 2026 também descreve áudio nativo incluído, mas as fórmulas de cobrança das plataformas continuam diferentes.
Qual a duração máxima?
2.0, Fast e Mini aceitam 4–15 segundos; 2.5, 4–30. Para sequências longas, gere vários vídeos e use o último quadro de um como primeiro do próximo. Só 2.5 retorna esse quadro por opção; nos demais, extraia por conta própria.
Um vídeo com falha é cobrado?
Não. Somente tarefas em SUCCESS são cobradas; FAILED e EXPIRED são gratuitas. O saldo é pré-pago, sem mensalidade. Calcule o orçamento pelo modelo, resolução e duração escolhidos; os valores exibidos arredondados não constituem garantia adicional de um teto exato de cobrança.
Fontes e consulta de preços
Preços da Orux verificados em 29 de outubro de 2026: 2.0, Fast, Mini, 2.5. CNY: link original Volcengine e página oficial atual. fal: comparativo Seedance, tarifas de 10 de agosto de 2026; endpoints revistos em 1º de novembro. Confira os três serviços antes de orçar.
Use estes modelos com uma única API
Uma API compatível com OpenAI para modelos de chat, imagem, vídeo e áudio, cobrada em Credits.
Artigos relacionados
Ver todos os artigos →
APIs de vídeo econômicas: Vidu, Wan, Kling e Seedance
Compare custo por segundo e vídeo, entradas e limites de Vidu, Wan, Kling e Seedance, com Python, exemplos reais e preços datados sem prometer mínimo global.

Kling 4.0 API: preços, parâmetros e vídeos reais
Compare Kling 4.0 na Orux e fal: preços, parâmetros, Python com ID salvo e dois vídeos reais, incluindo limites de recuperação e cobrança de novas tentativas.

API de imagem: preços 1K, 2K e 4K de 10 modelos
Compare dez modelos Orux de 29 de outubro de 2026: Credits por imagem e por 100, resolução, referências, tempos históricos e exemplo Python completo.