Doubao-Seedance-2-0

Q: What kinds of inputs does Seedance 2.0 support for video generation?

Seedance 2.0, metin istemleri, en fazla 9 görsel, en fazla 3 kısa video klibi ve en fazla 3 ses dosyası dahil olmak üzere çok modlu girdileri destekler; bunlar zengin ve kontrol edilebilir üretim için serbestçe birleştirilebilir.

Q: Can Seedance 2.0 maintain character and style consistency across multiple video shots?

Evet — Seedance 2.0, sahneler boyunca karakter, görsel stil ve atmosfer tutarlılığıyla uyumlu çok çekimli anlatım için tasarlanmıştır; bu da yaygın yapay zeka video kayması sorunlarını azaltır.

Q: What outputs and quality levels can I expect from Seedance 2.0 videos?

Seedance 2.0, yerel ses, senkronize diyalog ve doğal hareket senteziyle sinema kalitesinde videolar (2K çözünürlüğe kadar) üretebilir; tipik olarak 5–60 saniyelik klipler halinde.

Q: How does Seedance 2.0 handle audio and lip synchronization?

Model, sesi ve videoyu birlikte üretir; doğal konuşma ve ses efektleri için 8+ dilde fonem düzeyinde dudak senkronizasyonuyla yerel ses-görüntü senkronizasyonu sunar.

Q: Is Seedance 2.0 suitable for professional creative projects like marketing or narrative shorts?

Evet — Seedance 2.0, çok modlu kontrolü, çok çekimli sürekliliği ve yüksek doğrulukta çıktılarıyla pazarlama videoları, anlatı kısa filmleri, reklamlar ve diğer profesyonel uygulamalar için uygundur.

Q: How do referencing assets (images, video clips) work in Seedance 2.0 prompts?

Kullanıcılar referans varlıkları yükleyebilir ve ardından her birinin hareketi, kamera hareketini veya stilistik unsurları nasıl etkilemesi gerektiğini doğal dilde açıklayarak, üretilen içerik üzerinde ayrıntılı bir kontrol sağlar.

Q: Does Seedance 2.0 allow editing and extension of existing videos?

Evet — model, düzenlenmeyen kısımları korurken sahne ekleme, karakter değiştirme veya belirli segmentleri değiştirme gibi hedefli düzenlemelerin yanı sıra video genişletmeyi de destekler.

Q: What are known limitations or typical generation lengths with Seedance 2.0?

Tipik çıktı uzunlukları video başına ~5 ila ~60 saniye arasında değişir ve çok sayıda varlığın birleştirilmesi veya yüksek çözünürlük ayarları, üretim süresini artırabilir.

Saniyede:$0.08

Seedance 2.0, ByteDance’in sinematik, çok çekimli anlatı videoları üretimine odaklanan yeni nesil çok modlu video temel modelidir. Tek çekim metinden videoya demoların aksine Seedance 2.0, referans tabanlı kontrolü (görseller, kısa klipler, ses), çekimler arasında tutarlı karakter/stil sürekliliğini ve yerleşik ses/görüntü senkronizasyonunu vurgular — profesyonel yaratıcı ve ön görselleştirme iş akışları için yapay zekâ videolarını kullanışlı kılmayı hedefler.

Yeni

Ticari kullanım

Genel Bakış

Özellikler

Fiyatlandırma

API

Sürümler

Doubao Seedance 2.0'ın teknik özellikleri

Öğe	Ayrıntılar
Ürün ailesi	ByteDance Seedance video üretim ailesi
CometAPI slug	doubao-seedance-2-0
Sağlayıcı	ByteDance / BytePlus ModelArk
Model türü	Video üretim modeli
Girdi türleri	Metin, görsel, ses, video
Referans kapasitesi	Tek bir çok modlu istekte en fazla 9 görsel, 3 video klip ve 3 ses klibi
Çıktı türü	MP4 video
Çıktı çözünürlüğü	480p, 720p, 1080p
En-boy oranları	21:9, 16:9, 4:3, 1:1, 3:4, 9:16
Çıktı süresi	4–15 saniye
API tarzı	Eşzamansız görev tabanlı video üretimi

Doubao Seedance 2.0 nedir?

Doubao Seedance 2.0, ByteDance’in amiral gemisi çok modlu video üretim modelidir (Şubat 2026’da yayımlandı). Aynı anda birden fazla görsel, video klibi ve ses dosyasına referans vererek kesin yönetmen düzeyinde kontrol sağlayan birleşik ses-video ortak üretim mimarisi kullanır. Yerel ses senkronizasyonuyla sinematik, hareket açısından kararlı videolar üretmede mükemmeldir — gerçekçi fizik, tutarlı karakterler ve karmaşık sahne kompozisyonu gerektiren profesyonel yaratıcılar için idealdir.

CometAPI üzerinde Doubao Seedance 2.0’ın başlıca özellikleri

Birleşik çok modlu üretim: Tek bir iş akışında metin, görsel, ses ve video girdilerini kabul eder; böylece kullanıcılar yalnızca metin tabanlı bir üreticiye kıyasla daha zengin referans materyaliyle bir sahne yönetebilir.
Yönetmen tarzı kontrol: Model, performans, aydınlatma, gölge, kamera hareketi, hareket ritmi ve ses özelliklerine yönelik istemleri takip edecek şekilde tasarlanmıştır.
Video düzenleme ve genişletme: Seedance 2.0 yalnızca ilk üretimle sınırlı değildir; belirli klipleri, karakterleri, eylemleri ve hikaye örgülerini düzenlemeyi, ayrıca ileri/geri yönde genişletmeyi destekler.
Güçlü görsel-işitsel senkronizasyon: ByteDance, daha etkileyici sonuçlar için çift kanallı stereo çıkış ile arkaplan müziği, ortam sesleri ve seslendirme davranışının senkronize edildiğini vurgular.
Karmaşık sahnelerde yüksek kontrol edilebilirlik: Seedance 1.5’e kıyasla karmaşık etkileşimler, hareket sahneleri ve fiziksel olasılıkların daha iyi ele alınmasına vurgu yapılır.
Üretime yönelik çıktı: API, oran, süre ve filigran ayarlarının yapılandırılmasını destekler; bu da modeli tekrarlanabilir içerik iş akışları için pratik hale getirir.

Kıyaslama performansı

ByteDance, Seedance 2.0’ın dahili SeedVideoBench-2.0 değerlendirmesini kullandığını ve metinden videoya, görselden videoya ve çok modlu görev boyutları genelinde lider konuma yerleştiğini belirtiyor. Model, özellikle karmaşık etkileşim ve hareket sahnelerinde, Seedance 1.5’e kıyasla üretim kalitesi, fiziksel doğruluk, gerçekçilik ve kontrol edilebilirliği artırıyor.

CometAPI’de Seedance 2.0 API ve Seedance 2.0 Fast API modları

Model	CometAPI’deki Model Adı	En uygun kullanım	Ana fark
Seedance 2.0	doubao-seedance-2-0	En yüksek kaliteli çok modlu video üretimi	Seedance 2.0 ailesinde en geniş referans yığını ve en güçlü kontrol edilebilirlik.
Seedance 2.0 fast	doubao-seedance-2-0-fast	Kaliteden biraz ödün verilebildiğinde daha hızlı üretim	ByteDance’e göre Seedance 2.0 ile aynı model yeteneklerini korur, ancak daha hızlı üretir.
Seedance 1.5 Pro	doubao-seedance-1-5-pro	Önceki nesil ses-görüntü üretimi	Seedance 1.5 Pro yerel ortak ses-görüntü modeli olarak konumlandırılırken, Seedance 2.0 çok modlu referans ve düzenleme yığınını genişletir.

Rakiplere karşı güçlü yönler:

vs Kling 3.0: Daha iyi çok modlu referans kontrolü ve yerel ses.
vs Sora 2: Üstün referans hassasiyeti ve çok çekimli yetenek; az da olsa daha düşük maksimum süre.
vs Veo 3.1: Karakter tutarlılığı ve referans ağırlıklı iş akışlarında isteme uyumda daha güçlü; Veo ham sinematik derecelendirme ve daha uzun kliplerde önde.

İnsan odaklı ve performans yönlendirmeli videolarda öne çıkar.

CometAPI’de Seedance 2.0 Yapay Zekâ Video Üreticisini deneyin

Adım 1: Adım 1: API Anahtarı için Kaydolun

Herhangi bir kurulum veya kodlamaya gerek kalmadan Doubao Seedance 2.0’ı deneyimlemek için doğrudan CometAPI Playground’da başlayın. CometAPI hesabınıza giriş yapın, doubao-seedance-2-0 için model sayfasına gidin, referans görsellerinizi, kısa video kliplerinizi veya ses dosyalarınızı yükleyin, açıklayıcı bir istem ekleyin ve anında önizleme videoları üretin. Bu, Seedance 2.0’ın hareket tutarlılığı, karakter görünümü, kamera hareketleri ve yerel ses senkronizasyonunu nasıl ele aldığını anlamanın en hızlı yoludur.

Adım 2: CometAPI’de Seedance 2.0 için API Erişimi Alın

Doubao Seedance 2.0’a tam erişim sağlamak için yeni bir CometAPI anahtarı oluşturun veya mevcut anahtarınızı kullanın. Giriş yaptıktan sonra konsolunuzdaki API Token bölümüne gidin, yeni bir anahtar oluşturun ve kopyalayın. Ardından projelerinize entegre ederken desteklenen parametreleri gözden geçirmek için CometAPI’deki Seedance 2.0 model detay sayfasını ve API dokümanı bağlantısını ziyaret edin.

Adım 3: İlk İsteğinizi Seedance 2.0 API ile Gönderin

Açık bir metin istemi ve isteğe bağlı referans dosyaları (görseller, video veya ses) ile ilk video üretim isteğinizi göndermek için CometAPI uç noktasını kullanın. Sistem görevi eşzamansız işler, bir görev kimliği (ID) döndürür ve tamamlandığında indirilebilir bir MP4 video sağlar. Ardından istemlerinizi iyileştirebilir, ayarları düzenleyebilir ve Seedance 2.0 tarafından desteklenen pazarlama videoları, sosyal medya içerikleri, otomatik video hatları veya yaratıcı uygulamalar için ölçeklendirebilirsiniz.

Bu iş akışı, Playground’da hızlı denemeler ve CometAPI üzerinden üretim kullanımına sorunsuz geçiş sağlar.

CometAPI’de Seedance 2.0’ı seçmek için başlıca nedenler

Seedance 2.0 için neden CometAPI?

API veya Playground üzerinden doğrudan erişim
Kolay parametre kontrolü (süre, çözünürlük, format)
Hem metinden videoya hem görselden videoya iş akışlarını destekler
Eşzamansız video üretimi için yerleşik iş yönetimi

Birleşik ve geliştirici dostu API

CometAPI, tanıdık OpenAI tarzı biçimlerle veya özel video görev uç noktalarıyla sorunsuz çalışan temiz, standartlaştırılmış bir uç nokta sunar. Volcengine’in karmaşık kimlik doğrulaması veya bölgesel sınırlamalarıyla uğraşmadan, doğrudan görev oluşturma, polling ve MP4 indirmeleri elde edersiniz.

Uygun maliyetli fiyatlandırma

CometAPI genellikle doğrudan sağlayıcılara kıyasla saniye başına daha rekabetçi oranlar sunar; böylece bütçenizi zorlamadan pazarlama, sosyal medya veya otomatik hatlar için ölçekli, yüksek kaliteli videolar üretebilirsiniz.

Playground ile hızlı test

CometAPI Playground’da anında deneyin. Referans görselleri, videolar ve sesleri yükleyin, istemleri ince ayar yapın ve birkaç dakika içinde sonuçları önizleyin — üretime geçmeden önce stil, hareket ve ses senkronunu yinelemek için idealdir.

Kısacası, Seedance 2.0’ın yaratıcı gücünü — sınıfının en iyi referans kontrolü, doğal hareket ve yerel ses — doğrudan ByteDance erişimiyle uğraşmadan istiyorsanız, CometAPI bunu kullanmak için şu anda en iyi platformlardan biridir.

SSS

What kinds of inputs does Seedance 2.0 support for video generation?

Can Seedance 2.0 maintain character and style consistency across multiple video shots?

What outputs and quality levels can I expect from Seedance 2.0 videos?

How does Seedance 2.0 handle audio and lip synchronization?

Is Seedance 2.0 suitable for professional creative projects like marketing or narrative shorts?

How do referencing assets (images, video clips) work in Seedance 2.0 prompts?

Does Seedance 2.0 allow editing and extension of existing videos?

What are known limitations or typical generation lengths with Seedance 2.0?

Doubao-Seedance-2-0 için Fiyatlandırma

Doubao-Seedance-2-0 için çeşitli bütçelere ve kullanım ihtiyaçlarına uygun rekabetçi fiyatlandırmayı keşfedin. Esnek planlarımız sadece kullandığınız kadar ödeme yapmanızı sağlar ve ihtiyaçlarınız büyüdükçe kolayca ölçeklendirme imkanı sunar. Doubao-Seedance-2-0'in maliyetleri yönetilebilir tutarken projelerinizi nasıl geliştirebileceğini keşfedin.

doubao-seedance Video Generation Pricing

Parameters

Parameter	Description
Duration (seconds)	4–15 seconds, default 5 seconds
Aspect Ratio (size)	`21:9` / `16:9` / `4:3` / `1:1` / `3:4` / `9:16`, default `16:9`
Resolution	`480p` / `720p` / `1080p`*, default `720p`

*1080p only available for doubao-seedance-1-5-pro and doubao-seedance-1-0-pro

Pricing (Per Second)

Model	480p	720p	1080p
`doubao-seedance-2-0`	$0.08	$0.24	—
`doubao-seedance-2-0-fast`	$0.064	$0.192	—
`doubao-seedance-1-5-pro`	$0.018	$0.04147	$0.09331
`doubao-seedance-1-0-pro`	$0.01875	$0.0432	$0.0972

💡 Billed per second. Total cost = price per second × video duration (seconds). Duration range: 4–15 seconds.

Doubao-Seedance-2-0 için örnek kod ve API

Doubao-Seedance-2-0 için kapsamlı örnek kodlara ve API kaynaklarına erişerek entegrasyon sürecinizi kolaylaştırın. Ayrıntılı dokümantasyonumuz adım adım rehberlik sağlayarak projelerinizde Doubao-Seedance-2-0'in tüm potansiyelinden yararlanmanıza yardımcı olur.

POST

/v1/videos

Python
JavaScript
Curl

import json
import os
import time

import requests

# Get your CometAPI key from https://www.cometapi.com/console/token, and paste it here
COMETAPI_KEY = os.environ.get("COMETAPI_KEY") or "<YOUR_COMETAPI_KEY>"
BASE_URL = "https://api.cometapi.com"
OUTPUT_DIR = "./output"
POLL_INTERVAL_SECONDS = 10
RETRY_DELAY_SECONDS = 5
MAX_CREATE_ATTEMPTS = 5
MAX_QUERY_ATTEMPTS = 3
TERMINAL_STATUSES = {"success", "completed", "failed", "error"}
SUCCESS_STATUSES = {"success", "completed"}

def is_progress_complete(progress):
    if isinstance(progress, int):
        return progress >= 100
    if isinstance(progress, float):
        return progress >= 100
    if isinstance(progress, str):
        try:
            return float(progress.rstrip("%")) >= 100
        except ValueError:
            return False
    return False

def is_transient_status(status_code):
    return status_code == 429 or 500 <= status_code < 600

def create_task(files):
    for attempt in range(1, MAX_CREATE_ATTEMPTS + 1):
        response = requests.post(
            f"{BASE_URL}/v1/videos",
            headers=headers,
            files=files,
            timeout=30,
        )
        if response.ok:
            return response
        if not is_transient_status(response.status_code) or attempt == MAX_CREATE_ATTEMPTS:
            response.raise_for_status()
        print(f"Create request returned {response.status_code}, retrying...")
        time.sleep(RETRY_DELAY_SECONDS)

    raise SystemExit("Failed to create task.")

def get_task(task_id):
    for attempt in range(1, MAX_QUERY_ATTEMPTS + 1):
        response = requests.get(
            f"{BASE_URL}/v1/videos/{task_id}",
            headers=headers,
            timeout=15,
        )
        if response.ok:
            return response
        if not is_transient_status(response.status_code) or attempt == MAX_QUERY_ATTEMPTS:
            response.raise_for_status()
        print(f"Status request returned {response.status_code}, retrying...")
        time.sleep(RETRY_DELAY_SECONDS)

    raise SystemExit("Failed to query task.")

if COMETAPI_KEY == "<YOUR_COMETAPI_KEY>":
    print("Set COMETAPI_KEY before running this example.")
    raise SystemExit(0)

headers = {"Authorization": f"Bearer {COMETAPI_KEY}"}

create_response = create_task(
    {
        "prompt": (None, "A slow cinematic camera push across a coastal landscape at sunrise."),
        "model": (None, "doubao-seedance-2-0"),
        "seconds": (None, "5"),
        "size": (None, "16:9"),
        "resolution": (None, "720p"),
    }
)
create_response.raise_for_status()
create_result = create_response.json()

task_id = create_result.get("id") or create_result.get("task_id")
if not task_id:
    print(json.dumps(create_result, indent=2))
    raise SystemExit("No task id returned.")

print(f"Task created: {task_id}")
print(f"Initial status: {create_result.get('status')}")

while True:
    task_response = get_task(task_id)
    task_response.raise_for_status()
    task = task_response.json()
    status = str(task.get("status") or "unknown")
    normalized_status = status.lower()
    progress = task.get("progress")
    should_try_download = normalized_status in SUCCESS_STATUSES or (
        normalized_status == "unknown" and is_progress_complete(progress)
    )

    print(f"Status: {status}, progress: {progress}")

    if should_try_download or normalized_status in TERMINAL_STATUSES:
        if should_try_download:
            video_url = task.get("video_url") or ""
            content_url = f"{BASE_URL}/v1/videos/{task_id}/content"
            output_path = os.path.join(OUTPUT_DIR, f"{task_id}.mp4")

            os.makedirs(OUTPUT_DIR, exist_ok=True)
            with requests.get(
                content_url,
                headers=headers,
                timeout=120,
                stream=True,
            ) as video_response:
                video_response.raise_for_status()
                with open(output_path, "wb") as output_file:
                    for chunk in video_response.iter_content(chunk_size=8192):
                        if chunk:
                            output_file.write(chunk)

            print(f"Video URL: {video_url}")
            print(f"Content endpoint: {content_url}")
            print(f"Saved to {output_path}")
            print(f"File size: {os.path.getsize(output_path)} bytes")
        else:
            print(json.dumps(task, indent=2))
            raise SystemExit(1)
        break

    time.sleep(POLL_INTERVAL_SECONDS)

Python Code Example

import json
import os
import time

import requests

# Get your CometAPI key from https://www.cometapi.com/console/token, and paste it here
COMETAPI_KEY = os.environ.get("COMETAPI_KEY") or "<YOUR_COMETAPI_KEY>"
BASE_URL = "https://api.cometapi.com"
OUTPUT_DIR = "./output"
POLL_INTERVAL_SECONDS = 10
RETRY_DELAY_SECONDS = 5
MAX_CREATE_ATTEMPTS = 5
MAX_QUERY_ATTEMPTS = 3
TERMINAL_STATUSES = {"success", "completed", "failed", "error"}
SUCCESS_STATUSES = {"success", "completed"}


def is_progress_complete(progress):
    if isinstance(progress, int):
        return progress >= 100
    if isinstance(progress, float):
        return progress >= 100
    if isinstance(progress, str):
        try:
            return float(progress.rstrip("%")) >= 100
        except ValueError:
            return False
    return False


def is_transient_status(status_code):
    return status_code == 429 or 500 <= status_code < 600


def create_task(files):
    for attempt in range(1, MAX_CREATE_ATTEMPTS + 1):
        response = requests.post(
            f"{BASE_URL}/v1/videos",
            headers=headers,
            files=files,
            timeout=30,
        )
        if response.ok:
            return response
        if not is_transient_status(response.status_code) or attempt == MAX_CREATE_ATTEMPTS:
            response.raise_for_status()
        print(f"Create request returned {response.status_code}, retrying...")
        time.sleep(RETRY_DELAY_SECONDS)

    raise SystemExit("Failed to create task.")


def get_task(task_id):
    for attempt in range(1, MAX_QUERY_ATTEMPTS + 1):
        response = requests.get(
            f"{BASE_URL}/v1/videos/{task_id}",
            headers=headers,
            timeout=15,
        )
        if response.ok:
            return response
        if not is_transient_status(response.status_code) or attempt == MAX_QUERY_ATTEMPTS:
            response.raise_for_status()
        print(f"Status request returned {response.status_code}, retrying...")
        time.sleep(RETRY_DELAY_SECONDS)

    raise SystemExit("Failed to query task.")

if COMETAPI_KEY == "<YOUR_COMETAPI_KEY>":
    print("Set COMETAPI_KEY before running this example.")
    raise SystemExit(0)

headers = {"Authorization": f"Bearer {COMETAPI_KEY}"}

create_response = create_task(
    {
        "prompt": (None, "A slow cinematic camera push across a coastal landscape at sunrise."),
        "model": (None, "doubao-seedance-2-0"),
        "seconds": (None, "5"),
        "size": (None, "16:9"),
        "resolution": (None, "720p"),
    }
)
create_response.raise_for_status()
create_result = create_response.json()

task_id = create_result.get("id") or create_result.get("task_id")
if not task_id:
    print(json.dumps(create_result, indent=2))
    raise SystemExit("No task id returned.")

print(f"Task created: {task_id}")
print(f"Initial status: {create_result.get('status')}")

while True:
    task_response = get_task(task_id)
    task_response.raise_for_status()
    task = task_response.json()
    status = str(task.get("status") or "unknown")
    normalized_status = status.lower()
    progress = task.get("progress")
    should_try_download = normalized_status in SUCCESS_STATUSES or (
        normalized_status == "unknown" and is_progress_complete(progress)
    )

    print(f"Status: {status}, progress: {progress}")

    if should_try_download or normalized_status in TERMINAL_STATUSES:
        if should_try_download:
            video_url = task.get("video_url") or ""
            content_url = f"{BASE_URL}/v1/videos/{task_id}/content"
            output_path = os.path.join(OUTPUT_DIR, f"{task_id}.mp4")

            os.makedirs(OUTPUT_DIR, exist_ok=True)
            with requests.get(
                content_url,
                headers=headers,
                timeout=120,
                stream=True,
            ) as video_response:
                video_response.raise_for_status()
                with open(output_path, "wb") as output_file:
                    for chunk in video_response.iter_content(chunk_size=8192):
                        if chunk:
                            output_file.write(chunk)

            print(f"Video URL: {video_url}")
            print(f"Content endpoint: {content_url}")
            print(f"Saved to {output_path}")
            print(f"File size: {os.path.getsize(output_path)} bytes")
        else:
            print(json.dumps(task, indent=2))
            raise SystemExit(1)
        break

    time.sleep(POLL_INTERVAL_SECONDS)

JavaScript Code Example

import fs from "fs";
import path from "path";

// Get your CometAPI key from https://www.cometapi.com/console/token, and paste it here
const api_key = process.env.COMETAPI_KEY || "<YOUR_COMETAPI_KEY>";
const base_url = "https://api.cometapi.com";
const output_dir = "./output";
const poll_interval_ms = 10_000;
const retry_delay_ms = 5_000;
const max_create_attempts = 5;
const max_query_attempts = 3;
const terminal_statuses = new Set(["success", "completed", "failed", "error"]);
const success_statuses = new Set(["success", "completed"]);

function is_progress_complete(progress) {
  if (typeof progress === "number") {
    return progress >= 100;
  }

  if (typeof progress === "string") {
    const numeric = Number(progress.replace(/%$/, ""));
    return Number.isFinite(numeric) && numeric >= 100;
  }

  return false;
}

function is_transient_status(status) {
  return status === 429 || status >= 500;
}

async function fetch_with_retry(url, options, attempts, label) {
  for (let attempt = 1; attempt <= attempts; attempt += 1) {
    const response = await fetch(url, options);
    if (response.ok) {
      return response;
    }

    if (!is_transient_status(response.status) || attempt === attempts) {
      return response;
    }

    console.log(`${label} returned ${response.status}, retrying...`);
    await new Promise((resolve) => setTimeout(resolve, retry_delay_ms));
  }

  throw new Error(`${label} failed`);
}

if (api_key === "<YOUR_COMETAPI_KEY>") {
  console.log("Set COMETAPI_KEY before running this example.");
  process.exit(0);
}

const headers = {
  Authorization: `Bearer ${api_key}`,
};

const form = new FormData();
form.set("prompt", "A slow cinematic camera push across a coastal landscape at sunrise.");
form.set("model", "doubao-seedance-2-0");
form.set("seconds", "5");
form.set("size", "16:9");
form.set("resolution", "720p");

const create_response = await fetch_with_retry(`${base_url}/v1/videos`, {
  method: "POST",
  headers,
  body: form,
}, max_create_attempts, "Create request");

if (!create_response.ok) {
  console.log(await create_response.text());
  process.exit(1);
}

const create_result = await create_response.json();
const task_id = create_result.id || create_result.task_id;

if (!task_id) {
  console.log(JSON.stringify(create_result, null, 2));
  process.exit(1);
}

console.log(`Task created: ${task_id}`);
console.log(`Initial status: ${create_result.status}`);

while (true) {
  const task_response = await fetch_with_retry(`${base_url}/v1/videos/${task_id}`, {
    headers,
  }, max_query_attempts, "Status request");

  if (!task_response.ok) {
    console.log(await task_response.text());
    process.exit(1);
  }

  const task = await task_response.json();
  const status = String(task.status || "unknown");
  const normalized_status = status.toLowerCase();
  const progress = task.progress;
  const should_try_download = success_statuses.has(normalized_status) || (
    normalized_status === "unknown" && is_progress_complete(progress)
  );

  console.log(`Status: ${status}, progress: ${progress}`);

  if (should_try_download || terminal_statuses.has(normalized_status)) {
    if (should_try_download) {
      const video_url = task.video_url || "";
      const content_url = `${base_url}/v1/videos/${task_id}/content`;
      const output_path = path.join(output_dir, `${task_id}.mp4`);

      if (!fs.existsSync(output_dir)) {
        fs.mkdirSync(output_dir, { recursive: true });
      }

      const video_response = await fetch(content_url, { headers });
      if (!video_response.ok) {
        console.log(await video_response.text());
        process.exit(1);
      }

      const video_buffer = Buffer.from(await video_response.arrayBuffer());
      fs.writeFileSync(output_path, video_buffer);

      console.log(`Video URL: ${video_url}`);
      console.log(`Content endpoint: ${content_url}`);
      console.log(`Saved to ${output_path}`);
      console.log(`File size: ${fs.statSync(output_path).size} bytes`);
    } else {
      console.log(JSON.stringify(task, null, 2));
      process.exit(1);
    }
    break;
  }

  await new Promise((resolve) => setTimeout(resolve, poll_interval_ms));
}

Curl Code Example

#!/bin/bash

set -euo pipefail

# Get your CometAPI key from https://www.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"

if [[ -z "${COMETAPI_KEY:-}" ]]; then
  echo "Set COMETAPI_KEY before running this example."
  exit 0
fi

BASE_URL="https://api.cometapi.com"
OUTPUT_DIR="./output"
POLL_INTERVAL_SECONDS=10
RETRY_DELAY_SECONDS=5
MAX_CREATE_ATTEMPTS=5
MAX_QUERY_ATTEMPTS=3

is_progress_complete() {
  local progress="$1"
  local normalized="${progress%%%}"

  if [[ -z "$normalized" ]]; then
    return 1
  fi

  [[ "$normalized" =~ ^[0-9]+([.][0-9]+)?$ ]] || return 1
  awk -v value="$normalized" 'BEGIN { exit !(value >= 100) }'
}

create_task() {
  local attempt=1
  while (( attempt <= MAX_CREATE_ATTEMPTS )); do
    local response
    local status_code
    response=$(curl -sS -w $'\n%{http_code}' "${BASE_URL}/v1/videos" \
      -H "Authorization: Bearer $COMETAPI_KEY" \
      -F 'prompt="A slow cinematic camera push across a coastal landscape at sunrise."' \
      -F 'model="doubao-seedance-2-0"' \
      -F 'seconds="5"' \
      -F 'size="16:9"' \
      -F 'resolution="720p"')

    status_code=$(echo "$response" | tail -n 1)
    CREATE_RESPONSE=$(echo "$response" | sed '$d')

    if [[ "$status_code" =~ ^2 ]]; then
      return 0
    fi

    if [[ "$status_code" == "429" || "$status_code" =~ ^5 ]] && (( attempt < MAX_CREATE_ATTEMPTS )); then
      echo "Create request returned ${status_code}, retrying..."
      sleep "$RETRY_DELAY_SECONDS"
      (( attempt += 1 ))
      continue
    fi

    echo "$CREATE_RESPONSE"
    return 1
  done
}

get_task() {
  local task_id="$1"
  local attempt=1
  while (( attempt <= MAX_QUERY_ATTEMPTS )); do
    local response
    local status_code
    response=$(curl -sS -w $'\n%{http_code}' "${BASE_URL}/v1/videos/${task_id}" \
      -H "Authorization: Bearer $COMETAPI_KEY")

    status_code=$(echo "$response" | tail -n 1)
    TASK_RESPONSE=$(echo "$response" | sed '$d')

    if [[ "$status_code" =~ ^2 ]]; then
      return 0
    fi

    if [[ "$status_code" == "429" || "$status_code" =~ ^5 ]] && (( attempt < MAX_QUERY_ATTEMPTS )); then
      echo "Status request returned ${status_code}, retrying..."
      sleep "$RETRY_DELAY_SECONDS"
      (( attempt += 1 ))
      continue
    fi

    echo "$TASK_RESPONSE"
    return 1
  done
}

create_task

TASK_ID=$(echo "$CREATE_RESPONSE" | jq -r '.id // .task_id // empty')

if [[ -z "$TASK_ID" ]]; then
  echo "$CREATE_RESPONSE" | jq .
  echo "No task id returned."
  exit 1
fi

echo "Task created: $TASK_ID"
echo "Initial status: $(echo "$CREATE_RESPONSE" | jq -r '.status // empty')"

while true; do
  get_task "$TASK_ID"

  STATUS=$(echo "$TASK_RESPONSE" | jq -r '.status // empty')
  NORMALIZED_STATUS=$(echo "$STATUS" | tr '[:upper:]' '[:lower:]')
  PROGRESS=$(echo "$TASK_RESPONSE" | jq -r '.progress // empty')
  SHOULD_TRY_DOWNLOAD=0

  if [[ "$NORMALIZED_STATUS" == "success" || "$NORMALIZED_STATUS" == "completed" ]]; then
    SHOULD_TRY_DOWNLOAD=1
  elif [[ "$NORMALIZED_STATUS" == "unknown" ]] && is_progress_complete "$PROGRESS"; then
    SHOULD_TRY_DOWNLOAD=1
  fi

  echo "Status: ${STATUS}, progress: ${PROGRESS}"

  if [[ "$SHOULD_TRY_DOWNLOAD" == "1" || "$NORMALIZED_STATUS" == "failed" || "$NORMALIZED_STATUS" == "error" ]]; then
    if [[ "$SHOULD_TRY_DOWNLOAD" == "1" ]]; then
      VIDEO_URL=$(echo "$TASK_RESPONSE" | jq -r '.video_url // empty')
      CONTENT_URL="${BASE_URL}/v1/videos/${TASK_ID}/content"
      OUTPUT_PATH="${OUTPUT_DIR}/${TASK_ID}.mp4"

      mkdir -p "$OUTPUT_DIR"
      curl -fsS "$CONTENT_URL" \
        -H "Authorization: Bearer $COMETAPI_KEY" \
        -o "$OUTPUT_PATH"

      if [[ ! -s "$OUTPUT_PATH" ]]; then
        echo "Failed to download video"
        exit 1
      fi

      echo "Video URL: ${VIDEO_URL}"
      echo "Content endpoint: ${CONTENT_URL}"
      echo "Saved to ${OUTPUT_PATH}"
      echo "File size: $(wc -c < "$OUTPUT_PATH" | tr -d ' ') bytes"
    else
      echo "$TASK_RESPONSE" | jq .
      exit 1
    fi
    break
  fi

  sleep "$POLL_INTERVAL_SECONDS"
done

Doubao-Seedance-2-0 Sürümleri

Doubao-Seedance-2-0'nın birden fazla anlık görüntüye sahip olmasının nedeni; güncellemeler sonrası çıktı varyasyonları nedeniyle tutarlılık için eski anlık görüntülere ihtiyaç duyulması, geliştiricilere uyum ve geçiş için bir geçiş dönemi sağlanması ve kullanıcı deneyimini optimize etmek için küresel veya bölgesel uç noktalara karşılık gelen farklı anlık görüntüler içerebilir. Sürümler arasındaki detaylı farklar için lütfen resmi belgelere başvurun.

version
doubao-seedance-2-0
doubao-seedance-2-0-fast

Daha Fazla Model

İlgili Blog

Apr 17, 2026

Seedance 2.0 API'si Nasıl Kullanılır

Seedance 2.0 API, ByteDance’in en yeni çok modlu yapay zekâ video üretim modelidir (9 Nisan 2026’da piyasaya sürüldü). Tek bir istekte metin, görseller, video klipler ve sesi kabul ederek, yerleşik ses senkronizasyonu, yönetmen seviyesinde kamera kontrolü ve olağanüstü hareket tutarlılığıyla sinematik 4–15 saniyelik MP4 videolar üretir. Kullanmak için: CometAPI.com’da kaydolun, bir API anahtarı edinin, REST üzerinden asenkron bir görev gönderin, tamamlanma durumunu sorgulayın ve videoyu URL’den indirin.

Apr 11, 2026

HappyHorse-1.0 nedir? Seedance 2.0 nasıl karşılaştırılır?

HappyHorse-1.0 nedir, Artificial Analysis video liderlik tablosunun zirvesine neden çıktığını, Seedance 2.0 ile nasıl karşılaştırıldığını ve en son sıralamaların yapay zekâ video üretimi için ne anlama geldiğini öğrenin.

Mar 24, 2026

Seedance 2.0 nedir? Kapsamlı Bir Analiz

Seedance 2.0, ByteDance tarafından geliştirilen; metin, görseller, ses ve referans videolardan yüksek kaliteli, sinematik videolar üretebilen yeni nesil çok modlu bir yapay zekâ video oluşturma modelidir. Ses-video ortak üretimi, hareket kararlılığı ve referans tabanlı düzenleme özelliklerine sahiptir ve Artificial Analysis liderlik tablosu gibi küresel ölçütlerde hızla yükselerek 2026 yılında kendisini en iyi yapay zekâ video modelleri arasına konumlandırmıştır.