Seedance 2.0 API: Jak generować wideo AI programistycznie

Wygeneruj kinowy film AI jednym żądaniem HTTP. API Seedance 2.0 to ten sam potok generacji co platforma internetowa, udostępniony jako czysty interfejs REST z autoryzacją Bearer, webhookami i endpointami wsadowymi. Jeśli potrafisz wysłać żądanie POST, możesz zbudować potok generowania wideo.

Ten przewodnik obejmuje wszystko, co musisz wiedzieć, aby zintegrować Seedance 2.0 ze swoimi aplikacjami - uwierzytelnianie, endpointy, parametry, obsługę błędów oraz gotowe do produkcji przykłady kodu w Pythonie i JavaScript.

Streszczenie - API na pierwszy rzut oka

• Podstawowy URL: https://api.arteza.ai/v1
• Autoryzacja: Token Bearer w nagłówku Authorization
• Generowanie: Asynchroniczne - prześlij zadanie, sonduj lub poczekaj na webhook z potwierdzeniem
• Limity szybkości: 60 żądań na minutę, 5 równoczesnych generacji
• Modele: Seedance 2.0, 1.0 Pro, 1.0 Lite, Seedream v3/v4.5/v5 wszystkie w jednym API
• Koszt kredytów: Takie samo dynamiczne ceny za sekundę jak interfejs internetowy (~243-910 kredytów dla 2.0)

Co API może naprawdę zrobić

Wszystko, co robi interfejs internetowy, robi też API. Tekst na wideo, obraz na wideo, wybór modelu, kontrola czasu trwania, proporcje obrazu, opcje dźwięku oraz dostęp do każdego modelu na platformie. Endpointy wsadowe do generowania wielu klipów naraz. Powiadomienia webhook, dzięki czemu nie musisz sondować. Niestandardowe metadane, które są zwracane w wynikach w celu śledzenia testów A/B lub wariantów kampanii.

Obsługiwane modele

Wszystkie modele używają tej samej powierzchni API, tylko z różnymi identyfikatorami.

Uwierzytelnianie w 30 sekund

Wygeneruj klucz API z pulpitu nawigacyjnego w sekcji Ustawienia > Klucze API. Wyślij go jako token Bearer:

curl -H "Authorization: Bearer YOUR_API_KEY" \
     https://api.arteza.ai/v1/account/credits

Odpowiedź:

{
  "credits": 2750,
  "tier": "popular"
}

Reguły bezpieczeństwa, które się liczą:

• Nigdy nie wysyłaj klucza API w kodzie po stronie klienta ani w publicznych repozytoriach
• Przechowuj go w zmiennych środowiskowych (SEEDANCE_API_KEY)
• Regularnie rotuj klucze z pulpitu nawigacyjnego
• Każdy klucz dziedziczy saldo kredytów konta nadrzędnego

Endpoint tekstu na wideo

To endpoint, którego będziesz używać najczęściej.

POST /v1/generate/text-to-video

{
  "model": "seedance-2.0",
  "prompt": "Aerial shot of a coastal city at sunset, golden light reflecting off glass skyscrapers, cinematic drone footage",
  "duration": 10,
  "aspect_ratio": "16:9",
  "audio": true
}

Dokumentacja parametrów

Pomyślna odpowiedź

{
  "task_id": "task_abc123def456",
  "status": "queued",
  "model": "seedance-2.0",
  "credits_charged": 607,
  "estimated_time": 120,
  "created_at": "2026-04-10T14:30:00Z"
}

Generowanie jest asynchroniczne. Natychmiast otrzymujesz task_id i sondują w poszukiwaniu ukończenia (lub używasz webhooków).

Endpoint obrazu na wideo

Animuj obraz źródłowy za pomocą monitu ruchu.

POST /v1/generate/image-to-video
Content-Type: multipart/form-data

Wolisz nie przesyłać pliku? Zamiast tego przekaż image_url:

{
  "model": "seedance-2.0",
  "image_url": "https://example.com/photo.jpg",
  "prompt": "The woman turns her head slowly and smiles, wind gently blowing her hair",
  "duration": 8,
  "aspect_ratio": "16:9"
}

Sprawdzanie statusu generowania

Sonduj endpoint zadania, aby sprawdzić postęp.

GET /v1/tasks/{task_id}

Odpowiedź w trakcie przetwarzania

{
  "task_id": "task_abc123def456",
  "status": "processing",
  "progress": 65,
  "model": "seedance-2.0",
  "created_at": "2026-04-10T14:30:00Z",
  "estimated_completion": "2026-04-10T14:31:30Z"
}

Ukończona odpowiedź

{
  "task_id": "task_abc123def456",
  "status": "completed",
  "model": "seedance-2.0",
  "result": {
    "video_url": "https://cdn.arteza.ai/outputs/task_abc123def456.mp4",
    "duration": 10,
    "resolution": "1280x720",
    "has_audio": true,
    "file_size": 8542310
  },
  "credits_charged": 607,
  "created_at": "2026-04-10T14:30:00Z",
  "completed_at": "2026-04-10T14:31:28Z"
}

Wartości statusu

Adresy URL wideo wygasają w ciągu 24 godzin. Pobierz i przechowuj je na własnej infrastrukturze bez opóźnienia.

Chcesz wygenerować dane wyjściowe takie jak to programowo? Jesteś 30 sekund od pierwszego wywołania API. Uzyskaj darmowy klucz API →

Przykład Python gotowy do produkcji

Oto kompletny skrypt, który przesyła generowanie, sonduje ukończenie i pobiera wynik.

import os
import time
import requests

API_KEY = os.environ["SEEDANCE_API_KEY"]
BASE_URL = "https://api.arteza.ai/v1"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}


def generate_video(prompt, duration=8, aspect_ratio="16:9"):
    """Submit a text-to-video task. Returns task_id."""
    response = requests.post(
        f"{BASE_URL}/generate/text-to-video",
        headers=HEADERS,
        json={
            "model": "seedance-2.0",
            "prompt": prompt,
            "duration": duration,
            "aspect_ratio": aspect_ratio,
            "audio": True,
        },
    )
    response.raise_for_status()
    return response.json()["task_id"]


def wait_for_completion(task_id, poll_interval=5, timeout=300):
    """Poll until the task finishes. Returns result dict."""
    elapsed = 0
    while elapsed < timeout:
        response = requests.get(f"{BASE_URL}/tasks/{task_id}", headers=HEADERS)
        response.raise_for_status()
        data = response.json()

        if data["status"] == "completed":
            return data["result"]
        if data["status"] == "failed":
            raise RuntimeError(f"Generation failed: {data.get('error')}")

        time.sleep(poll_interval)
        elapsed += poll_interval

    raise TimeoutError(f"Task {task_id} did not complete within {timeout}s")


def download_video(video_url, output_path):
    """Stream the video to disk."""
    response = requests.get(video_url, stream=True)
    response.raise_for_status()
    with open(output_path, "wb") as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)


if __name__ == "__main__":
    task_id = generate_video(
        prompt="A cat sitting on a windowsill watching rain fall outside, cozy indoor lighting, shallow depth of field",
        duration=10,
    )
    print(f"Task submitted: {task_id}")

    result = wait_for_completion(task_id)
    print(f"Video ready: {result['video_url']}")

    download_video(result["video_url"], "output.mp4")
    print("Downloaded to output.mp4")

Przykład JavaScript (Node.js)

Ten sam przepływ pracy w nowoczesnym Node.js z natywnym fetch.

const API_KEY = process.env.SEEDANCE_API_KEY;
const BASE_URL = "https://api.arteza.ai/v1";

async function generateVideo(prompt, duration = 8, aspectRatio = "16:9") {
  const response = await fetch(`${BASE_URL}/generate/text-to-video`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "seedance-2.0",
      prompt,
      duration,
      aspect_ratio: aspectRatio,
      audio: true,
    }),
  });

  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  }
  const data = await response.json();
  return data.task_id;
}

async function waitForCompletion(taskId, pollMs = 5000, timeoutMs = 300000) {
  const start = Date.now();

  while (Date.now() - start < timeoutMs) {
    const response = await fetch(`${BASE_URL}/tasks/${taskId}`, {
      headers: { Authorization: `Bearer ${API_KEY}` },
    });
    const data = await response.json();

    if (data.status === "completed") return data.result;
    if (data.status === "failed") {
      throw new Error(`Generation failed: ${data.error}`);
    }

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

  throw new Error(`Task ${taskId} timed out`);
}

// Usage
const taskId = await generateVideo(
  "Timelapse of a flower blooming, macro lens, soft natural lighting",
  12
);
console.log(`Task submitted: ${taskId}`);

const result = await waitForCompletion(taskId);
console.log(`Video ready: ${result.video_url}`);

Obraz na wideo w Pythonie

Gdy chcesz przesłać obraz źródłowy, użyj multipart/form-data:

def generate_from_image(image_path, prompt, model="seedance-2.0", duration=8):
    """Generate video from a local image file."""
    with open(image_path, "rb") as img_file:
        response = requests.post(
            f"{BASE_URL}/generate/image-to-video",
            headers={"Authorization": f"Bearer {API_KEY}"},
            files={"image": img_file},
            data={
                "model": model,
                "prompt": prompt,
                "duration": duration,
                "aspect_ratio": "16:9",
                "audio": "true",
            },
        )
    response.raise_for_status()
    return response.json()["task_id"]

Obsługa błędów, która się nie przewraca

API używa standardowych kodów stanu HTTP z ustrukturyzowanymi treściami błędów.

Kształt odpowiedzi o błędzie

{
  "error": {
    "code": "insufficient_credits",
    "message": "Your account has 150 credits but this generation requires 607 credits.",
    "required_credits": 607,
    "available_credits": 150
  }
}

Zalecany wzorzec

try:
    task_id = generate_video(prompt)
except requests.exceptions.HTTPError as e:
    status = e.response.status_code
    if status == 402:
        error = e.response.json()["error"]
        print(f"Need {error['required_credits']} credits, have {error['available_credits']}")
        # Redirect the user to /pricing
    elif status == 429:
        retry_after = int(e.response.headers.get("Retry-After", 60))
        print(f"Rate limited. Retry after {retry_after}s.")
    else:
        raise

Limity szybkości i najlepsze praktyki produkcyjne

Limity

Pięć praktyk, które mają znaczenie w produkcji

1. Używaj webhooków, a nie sondowania, w dużej skali. Sondowanie marnuje wywołania API. Webhooks uruchamiają się dokładnie raz.
2. Wdrażaj wykładniczy backoff na odpowiedzi 429. Nie próbuj ponownie natychmiast.
3. Pobierz adresy URL wideo szybko. Wygasają w ciągu 24 godzin. Przechowuj je na własnej sieci CDN.
4. Sprawdzaj poprawność danych wejściowych po stronie klienta. Złap problemy z długością monitu i rozmiarem pliku przed trafieniem do API.
5. Sprawdź saldo kredytów przed zadaniami wsadowymi. 402 w trakcie wsadu jest irytujące. Najpierw zapytaj /account/credits.

Integracja webhooka

Dołącz webhook_url do żądania generowania, a Arteza opublikuje do niego dane, gdy zadanie się ukończy.

{
  "model": "seedance-2.0",
  "prompt": "...",
  "webhook_url": "https://yourapp.com/api/seedance/webhook"
}

Ładunek webhooka

{
  "event": "task.completed",
  "task_id": "task_abc123def456",
  "status": "completed",
  "result": {
    "video_url": "https://cdn.arteza.ai/outputs/task_abc123def456.mp4",
    "duration": 10,
    "resolution": "1280x720",
    "has_audio": true
  },
  "metadata": {
    "campaign_id": "summer-2026",
    "variant": "A"
  },
  "timestamp": "2026-04-10T14:31:28Z"
}

Żądania webhooka zawierają nagłówek X-Seedance-Signature - sygnaturę HMAC-SHA256 treści podpisaną tajnym webhookiem. Zawsze weryfikuj sygnaturę przed przetworzeniem zdarzeń.

Generowanie wsadowe

Gdy potrzebujesz wielu klipów, prześlij je jako wsad i otrzymaj jeden webhook, gdy wszystko się skończy.

POST /v1/generate/batch

{
  "tasks": [
    {
      "type": "text-to-video",
      "model": "seedance-2.0",
      "prompt": "Scene 1 description...",
      "duration": 8
    },
    {
      "type": "text-to-video",
      "model": "seedance-2.0",
      "prompt": "Scene 2 description...",
      "duration": 10
    },
    {
      "type": "image-to-video",
      "model": "seedance-1.0-pro",
      "image_url": "https://example.com/product.jpg",
      "prompt": "Slow rotation revealing product details",
      "duration": 6
    }
  ],
  "webhook_url": "https://yourapp.com/api/seedance/batch-complete"
}

Zadania w wsadzie przetwarzane są jednocześnie aż do limitu współbieżności.

Cztery przypadki użycia warte zbudowania

1. Wideo produktów e-commerce w skali

Zautomatyzuj animację produktów dla całego katalogu. Przetwarzaj swoją bazę danych produktów, przesyłaj jedno wideo na obraz dla każdego przedmiotu, przechowuj wynikowe adresy URL obok rekordu produktu.

products = get_products_from_database()

for product in products:
    task_id = generate_from_image(
        image_path=product["hero_image"],
        prompt=f"Slow 360 rotation of {product['name']}, studio lighting, white background",
        model="seedance-1.0-pro",
        duration=6,
    )
    save_task_mapping(product["id"], task_id)

Połącz to z przewodnik wideo e-commerce, aby uzyskać wskazówki dotyczące przepływu pracy.

2. Zautomatyzowane potoki mediów społecznych

Zasilaj generatory monitów popularnymi trendami, generuj codzienne wideo w pionie, wysyłaj do kolejki recenzji:

for topic in get_trending_topics():
    prompt = build_prompt(topic)
    task_id = generate_video(prompt, duration=6, aspect_ratio="9:16")
    queue_for_review(task_id, topic)

3. Testowanie A/B marketingu

Wygeneruj wiele wariantów kreatywnych ze śledzeniem metadanych:

variants = [
    "Product hero shot with warm lighting, luxury feel",
    "Product hero shot with bright lighting, energetic feel",
    "Product hero shot with moody lighting, premium feel",
]

for i, variant in enumerate(variants):
    generate_video(
        prompt=variant,
        duration=6,
        metadata={"variant": chr(65 + i), "campaign": "spring-launch"},
    )

Pole metadata jest zwracane w ładunku ukończenia, dzięki czemu możesz automatycznie kierować wyniki do właściwego wiadra kampanii.

4. Aplikacje interaktywne

Wbuduj generowanie wideo bezpośrednio do własnej aplikacji. Użytkownik wpisuje monit, backend wywołuje API, webhook dostarcza gotowy klip. Całą pętlę zajmuje ~90 sekund.

Podsumowanie

API Arteza jest proste do integracji i gotowe do produkcji. Prosta autoryzacja, czysty interfejs REST, webhooks do pracy asynchronicznej oraz endpointy wsadowe do skalowania. Jeśli używałeś Stripe lub dowolnego nowoczesnego REST API, poczujesz się jak w domu w dziesięć minut.

Aby uzyskać informacje o wycenie i optymalizacji kredytów, zobacz przewodnik cenowy. Aby zapoznać się z szerszym przeglądem produktu, przeczytaj kompletny przewodnik Seedance 2.0.

Gotowy do rozpoczęcia budowania? Utwórz darmowe konto →

Czytaj dalej: Kompletny przewodnik Seedance 2.0 • Przewodnik cenowy • Seedance 2.0 vs Seedance 1.0 • Seedance 2.0 vs Runway Gen-4